doc

alltypes

interface AbsentThrowableMessageProviderFactory

abstract fun translatableBased(translatable: Translatable): AbsentThrowableMessageProvider

object AbsentThrowableMessageProviderFactoryBuilder : AbsentThrowableMessageProviderFactory

inline fun translatableBased(translatable: Translatable): AbsentThrowableMessageProvider

interface AnyAssertions

abstract fun <T : Any> isNotSame(plant: AssertionPlant<T>, expected: T): Assertion
abstract fun <T> isNull(plant: AssertionPlantNullable<T>): Assertion
abstract fun <T : Any> isSame(plant: AssertionPlant<T>, expected: T): Assertion
abstract fun <T : Any> notToBe(plant: AssertionPlant<T>, expected: T): Assertion
abstract fun <T : Any> toBe(plant: AssertionPlant<T>, expected: T): Assertion

object AnyAssertionsBuilder : AnyAssertions

inline fun <T : Any> isNotSame(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
inline fun <T> isNull(plant: AssertionPlantNullable<T>): <ERROR CLASS>
inline fun <T : Any> isSame(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
inline fun <T : Any> notToBe(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
inline fun <T : Any> toBe(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
inline val typeTransformation: AnyTypeTransformationAssertionsBuilder

interface AnyTypeTransformation

interface Creator<S : Any, T : Any>

abstract fun create(parameterObject: ParameterObject<S, T>, canBeTransformed: (S) -> Boolean, transform: (S) -> T, failureHandler: FailureHandler<S, T>): Unit

interface FailureHandler<in S : Any, out T : Any>

abstract fun createAndAddAssertionToPlant(parameterObject: ParameterObject<S, T>): Unit
abstract fun createFailingAssertion(description: Translatable, representation: Any): Assertion

data class ParameterObject<out S : Any, in T : Any>

ParameterObject(description: Translatable, representation: Any, subjectPlant: BaseAssertionPlant<S?, *>, assertionCreator: AssertionPlant<T>.() -> Unit, warningTransformationFailed: Translatable)
val assertionCreator: AssertionPlant<T>.() -> Unit
val description: Translatable
val representation: Any
val subjectPlant: BaseAssertionPlant<S?, *>
val warningTransformationFailed: Translatable

interface AnyTypeTransformation

interface TypeTransformationFailureHandler<in T : Any, out TSub : Any>

abstract fun createAndAddAssertionToPlant(warningTransformationFailed: Translatable, subjectPlant: BaseAssertionPlant<T?, *>, failingAssertion: Assertion, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit

interface AnyTypeTransformationAssertions

abstract fun <T : Any, TSub : T> downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit, failureHandler: FailureHandler<T, TSub>): Unit
abstract fun <TSub : Any> isA(plant: AssertionPlant<Any>, subType: KClass<TSub>, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
abstract fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, assertionCreator: AssertionPlant<T>.() -> Unit): Unit
abstract fun <S : Any, T : Any> transform(parameterObject: ParameterObject<S, T>, canBeTransformed: (S) -> Boolean, transform: (S) -> T, failureHandler: FailureHandler<S, T>): Unit

object AnyTypeTransformationAssertionsBuilder : AnyTypeTransformationAssertions

inline fun <T : Any, TSub : T> downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, noinline assertionCreator: AssertionPlant<TSub>.() -> Unit, failureHandler: FailureHandler<T, TSub>): <ERROR CLASS>
inline val failureHandlers: AnyTypeTransformationFailureHandlerFactoryBuilder
inline fun <TSub : Any> isA(plant: AssertionPlant<Any>, subType: KClass<TSub>, noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): <ERROR CLASS>
inline fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, noinline assertionCreator: AssertionPlant<T>.() -> Unit): <ERROR CLASS>
inline fun <S : Any, T : Any> transform(parameterObject: ParameterObject<S, T>, noinline canBeTransformed: (S) -> Boolean, noinline transform: (S) -> T, failureHandler: FailureHandler<S, T>): <ERROR CLASS>

object AnyTypeTransformationFailureHandlerFactoryBuilder : FailureHandlerFactory

inline fun <S : Any, T : Any> newExplanatory(): <ERROR CLASS>
inline fun <S : Any, T : Any> newExplanatoryWithHint(noinline showHint: () -> Boolean, noinline failureHintFactory: () -> Assertion): <ERROR CLASS>

abstract class ArgumentsSupportingTranslator : Translator

ArgumentsSupportingTranslator(primaryLocale: Locale, fallbackLocales: List<Locale>)
protected val fallbackLocales: List<Locale>
protected val primaryLocale: Locale
fun translate(translatable: Translatable): String
protected abstract fun translateWithoutArgs(translatable: Translatable): String

typealias Assert<T> = AssertionPlant<T>
object AssertImpl

inline val any: AnyAssertionsBuilder
inline val bigDecimal: BigDecimalAssertionsBuilder
inline val builder: AssertionBuilder
fun <T, R : Any> changeSubject(originalPlant: BaseAssertionPlant<T, *>, subjectProvider: () -> R): AssertionPlant<R>
inline val charSequence: CharSequenceAssertionsBuilder
inline val collection: CollectionAssertionsBuilder
inline val collector: AssertionCollectorBuilder
inline val comparable: ComparableAssertionsBuilder
inline val coreFactory: <ERROR CLASS>
inline val feature: FeatureAssertionsBuilder
inline val floatingPoint: FloatingPointAssertionsBuilder
inline val iterable: IterableAssertionsBuilder
inline val map: MapAssertionsBuilder
inline val throwable: ThrowableAssertionsBuilder

@DslMarker annotation class AssertMarker

AssertMarker()

interface Assertion

abstract fun holds(): Boolean

interface AssertionBuilder

open fun createDescriptive(description: Translatable, representation: Any, test: () -> Boolean): DescriptiveAssertion
abstract fun <T : AssertionGroupType> customType(groupType: T): DefaultAssertionGroupBuilderOptions<T>
abstract val descriptive: DescriptiveAssertionHoldsOption
abstract val explanatory: ExplanatoryAssertionExplanationOption
abstract val explanatoryGroup: ExplanatoryAssertionGroupTypeOption
abstract val feature: DefaultAssertionGroupBuilderOptions<FeatureAssertionGroupType>
abstract val list: DefaultAssertionGroupBuilderOptions<ListAssertionGroupType>
abstract val summary: AssertionGroupDescriptionAndEmptyRepresentationOption<SummaryAssertionGroupType, AssertionsOption<SummaryAssertionGroupType, BasicAssertionGroupFinalStep>>

interface AssertionBuilderFinalStep<T : Assertion>

abstract fun build(): T

interface AssertionChecker

abstract fun check(assertionVerb: Translatable, representationProvider: () -> Any, assertions: List<Assertion>): Unit

interface AssertionCollector

open fun <T : Any> collect(plant: AssertionPlant<T>, subPlantAndAssertionCreator: CollectingAssertionPlant<T>.() -> Unit): AssertionGroup
abstract fun <T : Any> collect(subjectProvider: () -> T, subPlantAndAssertionCreator: CollectingAssertionPlant<T>.() -> Unit): AssertionGroup

object AssertionCollectorBuilder : AssertionCollector

inline fun <T : Any> collect(noinline subjectProvider: () -> T, noinline subPlantAndAssertionCreator: CollectingAssertionPlant<T>.() -> Unit): AssertionGroup
inline val forExplanation: ExplainingAssertionCollectorOption

interface AssertionComposer

abstract fun createDescriptiveWithFailureHint(description: Translatable, representation: Any, test: () -> Boolean, showHint: () -> Boolean, failureHintFactory: () -> Assertion): Assertion

interface AssertionFormatter

val CALL_FORMAT_GROUP: String
abstract fun canFormat(assertion: Assertion): Boolean
open fun format(assertion: Assertion, parameterObject: AssertionFormatterParameterObject): Unit
abstract fun formatGroup(assertionGroup: AssertionGroup, parameterObject: AssertionFormatterParameterObject, formatAssertions: (AssertionFormatterParameterObject, (Assertion) -> Unit) -> Unit): Unit
abstract fun formatNonGroup(assertion: Assertion, parameterObject: AssertionFormatterParameterObject): Unit
fun throwNotIntendedForAssertionGroups(): Unit

data class AssertionFormatterChosenOptions

AssertionFormatterChosenOptions(assertionFormatterFacade: AssertionFormatterFacade, objectFormatter: ObjectFormatter, translator: Translator)
val assertionFormatterFacade: AssertionFormatterFacade
val objectFormatter: ObjectFormatter
val translator: Translator

interface AssertionFormatterController

abstract fun format(assertion: Assertion, parameterObject: AssertionFormatterParameterObject): Unit
open fun isExplanatoryAssertionGroup(assertion: Assertion): Boolean
fun noSuitableAssertionFormatterFound(assertion: Assertion): Nothing
abstract fun register(assertionFormatter: AssertionFormatter): Unit

interface AssertionFormatterControllerOption

fun create(objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatterControllerOption
abstract val objectFormatter: ObjectFormatter
abstract val translator: Translator
abstract fun withAssertionFormatterController(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacadeOption
abstract fun withDefaultAssertionFormatterController(): AssertionFormatterFacadeOption

interface AssertionFormatterFacade

abstract fun format(assertion: Assertion, sb: StringBuilder, assertionFilter: (Assertion) -> Boolean): Unit
abstract fun register(assertionFormatterFactory: (AssertionFormatterController) -> AssertionFormatter): Unit

interface AssertionFormatterFacadeOption

abstract val assertionFormatterController: AssertionFormatterController
fun create(assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatterFacadeOption
abstract val objectFormatter: ObjectFormatter
abstract val translator: Translator
abstract fun withAssertionFormatterFacade(factory: (AssertionFormatterController) -> AssertionFormatterFacade): AssertionPairFormatterOption
abstract fun withDefaultAssertionFormatterFacade(): AssertionPairFormatterOption

class AssertionFormatterParameterObject

fun appendLnAndIndent(): Unit
fun appendLnIndentAndPrefix(): Unit
val assertionFilter: (Assertion) -> Boolean
fun createChildWithNewPrefix(newPrefix: String): AssertionFormatterParameterObject
fun createChildWithNewPrefixAndAdditionalIndent(newPrefix: String, additionalIndent: Int): AssertionFormatterParameterObject
fun createForDoNotFilterAssertionGroup(): AssertionFormatterParameterObject
fun indent(numberOfSpaces: Int): Unit
fun isNotInDoNotFilterGroup(): Boolean
fun new(sb: StringBuilder, assertionFilter: (Assertion) -> Boolean): AssertionFormatterParameterObject
val prefix: String
val sb: StringBuilder

interface AssertionGroup : Assertion

object Builder

class BasicAssertionGroupBuilder

BasicAssertionGroupBuilder(groupType: AssertionGroupType)
fun create(name: Translatable, subject: Any, assertion: Assertion): AssertionGroup
fun create(name: Translatable, subject: Any, assertions: List<Assertion>): AssertionGroup

class EmptyNameAndSubjectAssertionGroupBuilder

EmptyNameAndSubjectAssertionGroupBuilder(groupType: AssertionGroupType)
fun create(assertion: Assertion): AssertionGroup
fun create(assertions: List<Assertion>): AssertionGroup

class ExplanatoryAssertionGroupBuilder

ExplanatoryAssertionGroupBuilder(groupType: ExplanatoryAssertionGroupType)
fun create(assertion: Assertion): ExplanatoryAssertionGroup
fun create(assertions: List<Assertion>): ExplanatoryAssertionGroup

class ExplanatoryAssertionGroupOption

ExplanatoryAssertionGroupOption()
val withDefault: ExplanatoryAssertionGroupBuilder
fun withType(groupType: ExplanatoryAssertionGroupType): ExplanatoryAssertionGroupBuilder
val withWarning: ExplanatoryAssertionGroupBuilder

val explanatory: ExplanatoryAssertionGroupOption
val feature: BasicAssertionGroupBuilder
val invisible: EmptyNameAndSubjectAssertionGroupBuilder
val list: BasicAssertionGroupBuilder
val root: BasicAssertionGroupBuilder
val summary: BasicAssertionGroupBuilder
fun withType(groupType: AssertionGroupType): BasicAssertionGroupBuilder

abstract val assertions: List<Assertion>
abstract val description: Translatable
open fun holds(): <ERROR CLASS>
open val name: Translatable
abstract val representation: Any
open val subject: Any
abstract val type: AssertionGroupType

interface AssertionGroupDescriptionAndEmptyRepresentationOption<out T : AssertionGroupType, R>

fun <T : AssertionGroupType, R> create(type: T, factory: (T, Translatable, Any) -> R): AssertionGroupDescriptionAndEmptyRepresentationOption<T, R>
abstract val groupType: T
abstract fun withDescription(description: Translatable): R

interface AssertionGroupDescriptionAndRepresentationOption<out T : AssertionGroupType, R>

fun <T : AssertionGroupType, R> create(type: T, factory: (T, Translatable, Any) -> R): AssertionGroupDescriptionAndRepresentationOption<T, R>
abstract val groupType: T
open fun withDescriptionAndEmptyRepresentation(description: Translatable): R
open fun withDescriptionAndNullableRepresentation(description: Translatable, representation: Any?): R
open fun withDescriptionAndRepresentation(description: Translatable, representationProvider: () -> Any): R
abstract fun withDescriptionAndRepresentation(description: Translatable, representation: Any): R

interface AssertionGroupType : BulletPointIdentifier
interface AssertionPairFormatter

abstract fun format(parameterObject: AssertionFormatterParameterObject, translatable: Translatable, representation: Any): Unit
abstract fun formatGroupHeader(parameterObject: AssertionFormatterParameterObject, assertionGroup: AssertionGroup, newParameterObject: AssertionFormatterParameterObject): Unit

interface AssertionPairFormatterOption

fun create(assertionFormatterFacade: AssertionFormatterFacade, objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatterOption
fun create(options: AssertionFormatterChosenOptions): AssertionPairFormatterOption
abstract val options: AssertionFormatterChosenOptions
abstract fun withTextAssertionPairFormatter(factory: (ObjectFormatter, Translator) -> AssertionPairFormatter): TextAssertionFormatterOption
abstract fun withTextSameLineAssertionPairFormatter(): TextAssertionFormatterOption

interface AssertionPlant<out T : Any> : BaseAssertionPlant<T, AssertionPlant<T>>

abstract fun addAssertionsCreatedBy(assertionCreator: AssertionPlant<T>.() -> Unit): AssertionPlant<T>
open fun createAndAddAssertion(description: Translatable, expected: Any, test: () -> Boolean): AssertionPlant<T>

interface AssertionPlantNullable<out T> : BaseAssertionPlant<T, AssertionPlantNullable<T>>
interface AssertionPlantWithCommonFields<out T>

class CommonFields<out T>

CommonFields(assertionVerb: Translatable, subject: T, assertionChecker: AssertionChecker, nullRepresentation: Any)
CommonFields(assertionVerb: Translatable, subjectProvider: () -> T, representationProvider: () -> Any?, assertionChecker: AssertionChecker, nullRepresentation: Any)
val assertionChecker: AssertionChecker
val assertionVerb: Translatable
fun check(assertions: List<Assertion>): Unit
val representation: () -> Any
val subjectProvider: () -> T

abstract val commonFields: CommonFields<T>

enum class AssertionVerb : StringBasedTranslatable

ASSERT
EXPECT_THROWN
val value: String

enum class AssertionVerb : StringBasedTranslatable

ASSERT
ASSERT_THAT
ASSERT_THAT_THROWN
ASSERT_THROWN
EXPECT
EXPECT_THROWN
val value: String

object AssertionVerbFactory

fun checkException(act: () -> Unit): Builder
fun <T : Any> checkImmediately(subject: T): <ERROR CLASS>
fun <T : Any> checkLazily(subject: T, assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
fun <T> checkNullable(subject: T): <ERROR CLASS>

interface AssertionsOption<out T : AssertionGroupType, R>

fun <T : AssertionGroupType> asFactoryWithDefaultFinalStep(): (T, Translatable, Any) -> AssertionsOption<T, BasicAssertionGroupFinalStep>
fun <T : AssertionGroupType, R> create(groupType: T, description: Translatable, representation: Any, factory: (T, Translatable, Any, List<Assertion>) -> R): AssertionsOption<T, R>
abstract val description: Translatable
abstract val groupType: T
abstract val representation: Any
open fun withAssertion(assertion: Assertion): R
open fun withAssertions(assertion1: Assertion, assertion2: Assertion): R
open fun withAssertions(assertion1: Assertion, assertion2: Assertion, assertion3: Assertion): R
abstract fun withAssertions(assertions: List<Assertion>): R
fun <T : AssertionGroupType> withDefaultFinalStepAndEmptyDescriptionAndRepresentation(groupType: T): AssertionsOption<T, BasicAssertionGroupFinalStep>
fun <T : AssertionGroupType, R> withEmptyDescriptionAndRepresentation(groupType: T, factory: (T, Translatable, Any, List<Assertion>) -> R): AssertionsOption<T, R>

interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class AtLeastCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>

AtLeastCheckerOptionBase(times: Int, containsBuilder: Builder<T, S>, nameContainsNotFun: String, atLeastCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<T, S>
val times: Int

abstract class AtLeastCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>

AtLeastCheckerOptionBase(times: Int, containsBuilder: Builder<E, T, S>, nameContainsNotFun: String, atLeastCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<E, T, S>
val times: Int

open class AtLeastCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionBase<T, S>, AtLeastCheckerOption<T, S>

AtLeastCheckerOptionImpl(times: Int, containsBuilder: Builder<T, S>)

open class AtLeastCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtLeastCheckerOptionBase<E, T, S>, AtLeastCheckerOption<E, T, S>

AtLeastCheckerOptionImpl(times: Int, containsBuilder: Builder<E, T, S>)

open class AtLeastCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionBase<T, S>, AtLeastCheckerOption<T, S>

AtLeastCheckerOptionImpl(times: Int, containsBuilder: Builder<T, S>)

open class AtLeastCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtLeastCheckerOptionBase<E, T, S>, AtLeastCheckerOption<E, T, S>

AtLeastCheckerOptionImpl(times: Int, containsBuilder: Builder<E, T, S>)

interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class AtMostCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>

AtMostCheckerOptionBase(times: Int, containsBuilder: Builder<T, S>, nameContainsNotFun: String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<T, S>
val times: Int

abstract class AtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>

AtMostCheckerOptionBase(times: Int, containsBuilder: Builder<E, T, S>, nameContainsNotFun: String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<E, T, S>
val times: Int

open class AtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionBase<T, S>, AtMostCheckerOption<T, S>

AtMostCheckerOptionImpl(times: Int, containsBuilder: Builder<T, S>)

open class AtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtMostCheckerOptionBase<E, T, S>, AtMostCheckerOption<E, T, S>

AtMostCheckerOptionImpl(times: Int, containsBuilder: Builder<E, T, S>)

open class AtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionBase<T, S>, AtMostCheckerOption<T, S>

AtMostCheckerOptionImpl(times: Int, containsBuilder: Builder<T, S>)

open class AtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtMostCheckerOptionBase<E, T, S>, AtMostCheckerOption<E, T, S>

AtMostCheckerOptionImpl(times: Int, containsBuilder: Builder<E, T, S>)

interface BaseAssertionPlant<out T, out A : BaseAssertionPlant<T, A>>

abstract fun addAssertion(assertion: Assertion): A
abstract val subject: T
abstract val subjectProvider: () -> T

interface BaseReportingAssertionPlant<out T, out A : BaseAssertionPlant<T, A>> : BaseAssertionPlant<T, A>, AssertionPlantWithCommonFields<T>
data class BasicAssertionGroup : AssertionGroup

BasicAssertionGroup(type: AssertionGroupType, description: Translatable, representation: Any, assertions: List<Assertion>)
val assertions: List<Assertion>
val description: Translatable
val representation: Any
val type: AssertionGroupType

interface BasicAssertionGroupFinalStep : AssertionBuilderFinalStep<AssertionGroup>

abstract val assertions: List<Assertion>
fun create(groupType: AssertionGroupType, description: Translatable, representation: Any, assertions: List<Assertion>): BasicAssertionGroupFinalStep
abstract val description: Translatable
abstract val groupType: AssertionGroupType
abstract val representation: Any

class BasicDescriptiveAssertion : DescriptiveAssertion

BasicDescriptiveAssertion(description: Translatable, representation: Any, holds: Boolean)
BasicDescriptiveAssertion(description: Translatable, representation: Any, test: () -> Boolean)
val description: Translatable
fun holds(): Boolean
val representation: Any

class BasicExplanatoryAssertion : ExplanatoryAssertion

BasicExplanatoryAssertion(explanation: Any?)
val explanation: Any?

interface BigDecimalAssertions

abstract fun <T : BigDecimal> isEqualIncludingScale(plant: AssertionPlant<T>, expected: T, nameOfIsNumericallyEqualTo: String): Assertion
abstract fun <T : BigDecimal> isNotEqualIncludingScale(plant: AssertionPlant<T>, expected: T): Assertion
abstract fun <T : BigDecimal> isNotNumericallyEqualTo(plant: AssertionPlant<T>, expected: T): Assertion
abstract fun <T : BigDecimal> isNumericallyEqualTo(plant: AssertionPlant<T>, expected: T): Assertion

object BigDecimalAssertionsBuilder : BigDecimalAssertions

inline fun <T : BigDecimal> isEqualIncludingScale(plant: AssertionPlant<T>, expected: T, nameOfIsNumericallyEqualTo: String): <ERROR CLASS>
inline fun <T : BigDecimal> isNotEqualIncludingScale(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
inline fun <T : BigDecimal> isNotNumericallyEqualTo(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
inline fun <T : BigDecimal> isNumericallyEqualTo(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>

interface BulletPointIdentifier
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class ButAtMostCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>

ButAtMostCheckerOptionBase(times: Int, atLeastBuilder: WithTimesCheckerOption<T, S>, containsBuilder: Builder<T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<T, S>
val times: Int

abstract class ButAtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>

ButAtMostCheckerOptionBase(times: Int, atLeastBuilder: WithTimesCheckerOption<E, T, S>, containsBuilder: Builder<E, T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<E, T, S>
val times: Int

open class ButAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionBase<T, S>, ButAtMostCheckerOption<T, S>

ButAtMostCheckerOptionImpl(times: Int, atLeastBuilder: AtLeastCheckerOption<T, S>, containsBuilder: Builder<T, S>)

open class ButAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ButAtMostCheckerOptionBase<E, T, S>, ButAtMostCheckerOption<E, T, S>

ButAtMostCheckerOptionImpl(times: Int, atLeastBuilder: AtLeastCheckerOption<E, T, S>, containsBuilder: Builder<E, T, S>)

open class ButAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionBase<T, S>, ButAtMostCheckerOption<T, S>

ButAtMostCheckerOptionImpl(times: Int, atLeastBuilder: AtLeastCheckerOption<T, S>, containsBuilder: Builder<T, S>)

open class ButAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ButAtMostCheckerOptionBase<E, T, S>, ButAtMostCheckerOption<E, T, S>

ButAtMostCheckerOptionImpl(times: Int, atLeastBuilder: AtLeastCheckerOption<E, T, S>, containsBuilder: Builder<E, T, S>)

interface CharSequenceAssertions

abstract fun <T : CharSequence> containsBuilder(plant: AssertionPlant<T>): Builder<T, NoOpSearchBehaviour>
abstract fun <T : CharSequence> containsNotBuilder(plant: AssertionPlant<T>): Builder<T, NotSearchBehaviour>
abstract fun <T : CharSequence> endsNotWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion
abstract fun <T : CharSequence> endsWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion
abstract fun <T : CharSequence> isEmpty(plant: AssertionPlant<T>): Assertion
abstract fun <T : CharSequence> isNotEmpty(plant: AssertionPlant<T>): Assertion
abstract fun <T : CharSequence> startsNotWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion
abstract fun <T : CharSequence> startsWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion

object CharSequenceAssertionsBuilder : CharSequenceAssertions

inline val contains: CharSequenceContainsAssertionsBuilder
inline fun <T : CharSequence> containsBuilder(plant: AssertionPlant<T>): <ERROR CLASS>
inline fun <T : CharSequence> containsNotBuilder(plant: AssertionPlant<T>): <ERROR CLASS>
inline fun <T : CharSequence> endsNotWith(plant: AssertionPlant<T>, expected: CharSequence): <ERROR CLASS>
inline fun <T : CharSequence> endsWith(plant: AssertionPlant<T>, expected: CharSequence): <ERROR CLASS>
inline fun <T : CharSequence> isEmpty(plant: AssertionPlant<T>): <ERROR CLASS>
inline fun <T : CharSequence> isNotEmpty(plant: AssertionPlant<T>): <ERROR CLASS>
inline fun <T : CharSequence> startsNotWith(plant: AssertionPlant<T>, expected: CharSequence): <ERROR CLASS>
inline fun <T : CharSequence> startsWith(plant: AssertionPlant<T>, expected: CharSequence): <ERROR CLASS>

interface CharSequenceContains

interface Checker : Checker, Checker
interface Creator<in T : CharSequence, in SC> : Creator<T, SC>, Creator<T, SC>
interface SearchBehaviour : SearchBehaviour, SearchBehaviour
interface Searcher<S : SearchBehaviour> : Searcher<S>

interface CharSequenceContains

interface Builder<out T : CharSequence, out S : SearchBehaviour> : Builder<T, S>
interface Checker : Checker
interface CheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S, Checker, Builder<T, S>>
interface Creator<in T : CharSequence, in SC> : Creator<T, SC>
interface SearchBehaviour : SearchBehaviour
interface Searcher<S : SearchBehaviour>

abstract fun search(searchIn: CharSequence, searchFor: Any): Int

class CharSequenceContainsAssertionCreator<T : CharSequence, S : SearchBehaviour> : ContainsObjectsAssertionCreator<T, Any, S, Checker>, Creator<T, Any>

CharSequenceContainsAssertionCreator(searchBehaviour: S, searcher: Searcher<S>, checkers: List<Checker>)
protected val descriptionContains: DescriptionCharSequenceAssertion
protected val descriptionNumberOfOccurrences: DescriptionCharSequenceAssertion
protected fun search(plant: AssertionPlant<T>, searchCriterion: Any): Int

interface CharSequenceContainsAssertions

abstract fun <T : CharSequence> defaultTranslationOf(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Translatable>): AssertionGroup
abstract fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Translatable>): AssertionGroup
abstract fun <T : CharSequence> regex(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<String>): AssertionGroup
abstract fun <T : CharSequence> regexIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<String>): AssertionGroup
abstract fun <T : CharSequence> values(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Any>): AssertionGroup
abstract fun <T : CharSequence> valuesIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Any>): AssertionGroup

object CharSequenceContainsAssertionsBuilder : CharSequenceContainsAssertions

inline fun <T : CharSequence> defaultTranslationOf(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Translatable>): <ERROR CLASS>
inline fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Translatable>): <ERROR CLASS>
inline fun <T : CharSequence> regex(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<String>): <ERROR CLASS>
inline fun <T : CharSequence> regexIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<String>): <ERROR CLASS>
inline val searchBehaviours: CharSequenceContainsSearchBehaviourFactoryBuilder
inline fun <T : CharSequence> values(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Any>): <ERROR CLASS>
inline fun <T : CharSequence> valuesIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Any>): <ERROR CLASS>

class CharSequenceContainsAtLeastChecker : CharSequenceContainsChecker

CharSequenceContainsAtLeastChecker(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtLeastCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtLeastCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtLeastCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

abstract class CharSequenceContainsAtLeastCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtLeastCheckerBuilderBase(times: Int, containsBuilder: Builder<T, S>, nameContainsNotFun: String, atLeastCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: Builder<T, S>
val times: Int

class CharSequenceContainsAtMostChecker : CharSequenceContainsChecker

CharSequenceContainsAtMostChecker(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtMostCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtMostCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtMostCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

abstract class CharSequenceContainsAtMostCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtMostCheckerBuilderBase(times: Int, containsBuilder: Builder<T, S>, nameContainsNotFun: String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: Builder<T, S>
val times: Int

class CharSequenceContainsBuilder<out T : CharSequence, out S : SearchBehaviour> : ContainsBuilder<T, S>, Builder<T, S>

CharSequenceContainsBuilder(plant: AssertionPlant<T>, searchBehaviour: S)

open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, containsBuilder: Builder<T, S>)

open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, containsBuilder: Builder<T, S>)

open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, containsBuilder: Builder<T, S>)

abstract class CharSequenceContainsButAtMostCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsButAtMostCheckerBuilderBase(times: Int, atLeastBuilder: CharSequenceContainsAtLeastCheckerBuilderBase<T, S>, containsBuilder: Builder<T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: Builder<T, S>
val times: Int

abstract class CharSequenceContainsChecker : ContainsChecker, Checker

CharSequenceContainsChecker(times: Int, correctCall: String, wrongCall: (Int) -> String)

interface CharSequenceContainsCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ContainsCheckerBuilder<T, S, Checker, Builder<T, S>>, CheckerOption<T, S>
class CharSequenceContainsExactlyChecker : CharSequenceContainsChecker

CharSequenceContainsExactlyChecker(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsExactlyCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsExactlyCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsExactlyCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

abstract class CharSequenceContainsExactlyCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsExactlyCheckerBuilderBase(times: Int, containsBuilder: Builder<T, S>, nameContainsNotFun: String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: Builder<T, S>
val times: Int

class CharSequenceContainsIgnoringCaseIndexSearcher : Searcher<CharSequenceContainsIgnoringCaseSearchBehaviour>

CharSequenceContainsIgnoringCaseIndexSearcher()
fun search(searchIn: CharSequence, searchFor: Any): Int

class CharSequenceContainsIgnoringCaseRegexSearcher : Searcher<CharSequenceContainsIgnoringCaseSearchBehaviour>

CharSequenceContainsIgnoringCaseRegexSearcher()
fun search(searchIn: CharSequence, searchFor: Any): Int

open class CharSequenceContainsIgnoringCaseSearchBehaviour : SearchBehaviour, IgnoringCaseSearchBehaviour

CharSequenceContainsIgnoringCaseSearchBehaviour(previousBehaviour: NoOpSearchBehaviour)
open fun decorateDescription(description: Translatable): Translatable

class CharSequenceContainsIndexSearcher : Searcher<CharSequenceContainsNoOpSearchBehaviour>

CharSequenceContainsIndexSearcher()
fun search(searchIn: CharSequence, searchFor: Any): Int

open class CharSequenceContainsNoOpSearchBehaviour : SearchBehaviour, NoOpSearchBehaviour

CharSequenceContainsNoOpSearchBehaviour()

class CharSequenceContainsNotChecker : Checker

CharSequenceContainsNotChecker()
fun createAssertion(foundNumberOfTimes: Int): Assertion

open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotCheckerBuilder(containsBuilder: Builder<T, S>)

open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotCheckerBuilder(containsBuilder: Builder<T, S>)

open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotCheckerBuilder(containsBuilder: Builder<T, S>)

abstract class CharSequenceContainsNotCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotCheckerBuilderBase(containsBuilder: Builder<T, S>)
open val checkers: <ERROR CLASS>
open val containsBuilder: Builder<T, S>

open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

abstract class CharSequenceContainsNotOrAtMostCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotOrAtMostCheckerBuilderBase(times: Int, containsBuilder: Builder<T, S>, nameContainsNotFun: String, notOrAtMostCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: Builder<T, S>
val times: Int

open class CharSequenceContainsNotSearchBehaviour : CharSequenceContainsNoOpSearchBehaviour, NotSearchBehaviour

CharSequenceContainsNotSearchBehaviour()
open fun decorateDescription(description: Translatable): DescriptionCharSequenceAssertion

class CharSequenceContainsRegexSearcher : Searcher<CharSequenceContainsNoOpSearchBehaviour>

CharSequenceContainsRegexSearcher()
fun search(searchIn: CharSequence, searchFor: Any): Int
fun search(searchIn: CharSequence, pattern: Pattern): Int

object CharSequenceContainsSearchBehaviourFactoryBuilder : SearchBehaviourFactory

inline fun <T : CharSequence> ignoringCase(containsBuilder: Builder<T, NoOpSearchBehaviour>): Builder<T, IgnoringCaseSearchBehaviour>

object CharSequenceContainsSearchersKt

fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> standardUebersetzungVon(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> wert(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> werte(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>

object CharSequenceContainsSearchersKt

fun <T : CharSequence> defaultTranslationOf(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> value(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> values(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>

object CharSequenceContainsSearchersKt

fun <T : CharSequence> defaultTranslationOf(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, translatable: Translatable): AssertionPlant<T>
fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, translatable: Translatable): AssertionPlant<T>
fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, patterns: RegexPatterns): AssertionPlant<T>
fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, values: Values<Any>): AssertionPlant<T>
fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, translatables: DefaultTranslationsOf): AssertionPlant<T>
fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, patterns: RegexPatterns): AssertionPlant<T>
fun <T : CharSequence> value(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, values: Values<Any>): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, translatables: DefaultTranslationsOf): AssertionPlant<T>

interface CheckerFactory

abstract fun newAtLeastChecker(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String): Checker
abstract fun newAtMostChecker(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String): Checker
abstract fun newExactlyChecker(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String): Checker
abstract fun newNotChecker(): Checker

interface CheckerFactory

abstract fun newAtLeastChecker(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String): Checker
abstract fun newAtMostChecker(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String): Checker
abstract fun newExactlyChecker(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String): Checker
abstract fun newNotChecker(): Checker

interface CheckingAssertionPlant<out T : Any> : AssertionPlant<T>

abstract fun addAssertionsCreatedBy(assertionCreator: AssertionPlant<T>.() -> Unit): CheckingAssertionPlant<T>
abstract fun allAssertionsHold(): Boolean

interface CollectingAssertionPlant<out T : Any> : AssertionPlant<T>

abstract fun addAssertionsCreatedBy(assertionCreator: AssertionPlant<T>.() -> Unit): CollectingAssertionPlant<T>
abstract fun getAssertions(): List<Assertion>
abstract val subject: T

interface CollectionAssertions

abstract fun <T : Collection<*>> hasSize(plant: AssertionPlant<T>, size: Int): Assertion
abstract fun <T : Collection<*>> isEmpty(plant: AssertionPlant<T>): Assertion
abstract fun <T : Collection<*>> isNotEmpty(plant: AssertionPlant<T>): Assertion

object CollectionAssertionsBuilder : CollectionAssertions

inline fun <T : Collection<*>> hasSize(plant: AssertionPlant<T>, size: Int): <ERROR CLASS>
inline fun <T : Collection<*>> isEmpty(plant: AssertionPlant<T>): <ERROR CLASS>
inline fun <T : Collection<*>> isNotEmpty(plant: AssertionPlant<T>): <ERROR CLASS>

interface ComparableAssertions

abstract fun <T1 : Comparable<T2>, T2> isGreaterOrEquals(plant: AssertionPlant<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isGreaterThan(plant: AssertionPlant<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isLessOrEquals(plant: AssertionPlant<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isLessThan(plant: AssertionPlant<T1>, expected: T2): Assertion

object ComparableAssertionsBuilder : ComparableAssertions

inline fun <T1 : Comparable<T2>, T2> isGreaterOrEquals(plant: AssertionPlant<T1>, expected: T2): <ERROR CLASS>
inline fun <T1 : Comparable<T2>, T2> isGreaterThan(plant: AssertionPlant<T1>, expected: T2): <ERROR CLASS>
inline fun <T1 : Comparable<T2>, T2> isLessOrEquals(plant: AssertionPlant<T1>, expected: T2): <ERROR CLASS>
inline fun <T1 : Comparable<T2>, T2> isLessThan(plant: AssertionPlant<T1>, expected: T2): <ERROR CLASS>

interface Contains

interface Checker : Checker
interface Creator<in T : Any, in SC> : Creator<T, SC>
interface SearchBehaviour : SearchBehaviour

interface Contains

interface Builder<out T : Any, out S : SearchBehaviour>

abstract val plant: AssertionPlant<T>
abstract val searchBehaviour: S

interface Checker

abstract fun createAssertion(foundNumberOfTimes: Int): Assertion

interface CheckerOption<out T : Any, out S : SearchBehaviour, out C : Checker, out B : Builder<T, S>>

abstract val checkers: List<C>
abstract val containsBuilder: B

interface Creator<in T : Any, in SC>

abstract fun createAssertionGroup(plant: AssertionPlant<T>, searchCriteria: List<SC>): AssertionGroup

interface SearchBehaviour

abstract fun decorateDescription(description: Translatable): Translatable

abstract class ContainsAssertionCreator<T : Any, S, C : Checker> : Creator<T, S>

ContainsAssertionCreator(checkers: List<C>)
fun createAssertionGroup(plant: AssertionPlant<T>, searchCriteria: List<S>): AssertionGroup
fun createAssertionGroup(plant: AssertionPlant<T>, searchCriterion: S, otherSearchCriteria: Array<out S>): AssertionGroup
protected abstract fun createAssertionGroupForSearchCriteriaAssertions(assertions: List<Assertion>): AssertionGroup
protected abstract fun searchAndCreateAssertion(plant: AssertionPlant<T>, searchCriterion: S, featureFactory: (numberOfOccurrences: Int, description: Translatable) -> AssertionGroup): AssertionGroup

abstract class ContainsBuilder<out T : Any, out S : SearchBehaviour> : Builder<T, S>

ContainsBuilder(plant: AssertionPlant<T>, searchBehaviour: S)
open val plant: AssertionPlant<T>
open val searchBehaviour: S

abstract class ContainsChecker : Checker

ContainsChecker(times: Int, correctCall: String, wrongCall: (Int) -> String)
protected fun createBasicAssertion(description: Translatable, check: Boolean): DescriptiveAssertion
val times: Int

interface ContainsCheckerBuilder<out T : Any, out S : SearchBehaviour, out C : Checker, out B : Builder<T, S>> : CheckerOption<T, S, C, B>
abstract class ContainsObjectsAssertionCreator<T : Any, S, B : SearchBehaviour, C : Checker> : ContainsAssertionCreator<T, S, C>

ContainsObjectsAssertionCreator(searchBehaviour: B, checkers: List<C>)
protected fun createAssertionGroupForSearchCriteriaAssertions(assertions: List<Assertion>): AssertionGroup
protected abstract val descriptionContains: Translatable
protected abstract val descriptionNumberOfOccurrences: Translatable
protected abstract fun search(plant: AssertionPlant<T>, searchCriterion: S): Int
protected fun searchAndCreateAssertion(plant: AssertionPlant<T>, searchCriterion: S, featureFactory: (Int, Translatable) -> AssertionGroup): AssertionGroup

interface CoreFactory

abstract fun newAssertionFormatterController(): AssertionFormatterController
abstract fun newAssertionFormatterFacade(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacade
abstract fun <T : Any> newCheckingPlant(subjectProvider: () -> T): CheckingAssertionPlant<T>
abstract fun <T : Any> newCollectingPlant(subjectProvider: () -> T): CollectingAssertionPlant<T>
abstract fun <T> newDelegatingAssertionChecker(subjectPlant: BaseAssertionPlant<T, *>): AssertionChecker
abstract fun newDetailedObjectFormatter(translator: Translator): ObjectFormatter
abstract fun <T : Any> newFeatureAssertionChecker(subjectPlant: AssertionPlant<T>): AssertionChecker
abstract fun newLocaleOrderDecider(): LocaleOrderDecider
abstract fun newMethodCallFormatter(): MethodCallFormatter
abstract fun newOnlyFailureReporter(assertionFormatterFacade: AssertionFormatterFacade): Reporter
abstract fun newPropertiesBasedTranslationSupplier(): TranslationSupplier
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subjectProvider: () -> T, assertionChecker: AssertionChecker): ReportingAssertionPlant<T>
abstract fun <T : Any> newReportingPlant(commonFields: CommonFields<T>): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlantAndAddAssertionsCreatedBy(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter, assertionCreator: AssertionPlant<T>.() -> Unit): AssertionPlant<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter, nullRepresentation: Any = RawString.NULL): ReportingAssertionPlantNullable<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subjectProvider: () -> T, assertionChecker: AssertionChecker, nullRepresentation: Any = RawString.NULL): ReportingAssertionPlantNullable<T>
abstract fun <T> newReportingPlantNullable(commonFields: CommonFields<T>): ReportingAssertionPlantNullable<T>
abstract fun newTextExplanatoryAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController): AssertionFormatter
abstract fun newTextFallbackAssertionFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextFeatureAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextListAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextSameLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newTextSummaryAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newThrowingAssertionChecker(reporter: Reporter): AssertionChecker
abstract fun newTranslator(translationSupplier: TranslationSupplier, localeOrderDecider: LocaleOrderDecider, primaryLocale: Locale, fallbackLocales: List<Locale>): Translator
abstract fun registerTextAssertionFormatterCapabilities(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterFacade: AssertionFormatterFacade, textAssertionPairFormatter: AssertionPairFormatter, objectFormatter: ObjectFormatter, translator: Translator): Unit

typealias DefaultAssertionGroupBuilderOptions<T> = AssertionGroupDescriptionAndRepresentationOption<T, AssertionsOption<T, BasicAssertionGroupFinalStep>>
object DefaultExplanatoryAssertionGroupType : ExplanatoryAssertionGroupType
object DefaultFeatureAssertionGroupType : FeatureAssertionGroupType
object DefaultIndentAssertionGroupType : IndentAssertionGroupType
object DefaultListAssertionGroupType : ListAssertionGroupType
object DefaultSummaryAssertionGroupType : SummaryAssertionGroupType
class DefaultTranslationsOf

DefaultTranslationsOf(expected: Translatable, vararg otherExpected: Translatable)
val expected: Translatable
vararg val otherExpected: Array<out Translatable>
fun toList(): List<Translatable>

class DeprecationTestEngine

DeprecationTestEngine()
fun discover(discoveryRequest: <ERROR CLASS>, uniqueId: <ERROR CLASS>): <ERROR CLASS>
fun execute(request: <ERROR CLASS>): <ERROR CLASS>
fun getId(): String

enum class DescriptionAnyAssertion : StringBasedTranslatable

IS_NOT_SAME
IS_SAME
NOT_TO_BE
TO_BE
val value: String

enum class DescriptionAnyAssertion : StringBasedTranslatable

IS_NOT_SAME
IS_SAME
NOT_TO_BE
TO_BE
val value: String

enum class DescriptionBasic : StringBasedTranslatable

IS
IS_NOT
val value: String

enum class DescriptionBasic : StringBasedTranslatable

IS
IS_NOT
val value: String

enum class DescriptionBigDecimalAssertion : StringBasedTranslatable

FAILURE_TO_BE_BUT_NUMERICALLY_EQUAL
IS_EQUAL_INCLUDING_SCALE
IS_NOT_EQUAL_INCLUDING_SCALE
IS_NOT_NUMERICALLY_EQUAL_TO
IS_NUMERICALLY_EQUAL_TO
val value: String

enum class DescriptionBigDecimalAssertion : StringBasedTranslatable

FAILURE_IS_EQUAL_INCLUDING_SCALE_BUT_NUMERICALLY_EQUAL
IS_EQUAL_INCLUDING_SCALE
IS_NOT_EQUAL_INCLUDING_SCALE
IS_NOT_NUMERICALLY_EQUAL_TO
IS_NUMERICALLY_EQUAL_TO
val value: String

enum class DescriptionCharSequenceAssertion : StringBasedTranslatable

AT_LEAST
AT_MOST
CONTAINS
CONTAINS_NOT
EMPTY
ENDS_NOT_WITH
ENDS_WITH
EXACTLY
IGNORING_CASE
NUMBER_OF_OCCURRENCES
STARTS_NOT_WITH
STARTS_WITH
val value: String

enum class DescriptionCharSequenceAssertion : StringBasedTranslatable

AT_LEAST
AT_MOST
CONTAINS
CONTAINS_NOT
EMPTY
ENDS_NOT_WITH
ENDS_WITH
EXACTLY
IGNORING_CASE
NUMBER_OF_OCCURRENCES
STARTS_NOT_WITH
STARTS_WITH
STRING_MATCHING_REGEX
VALUE
val value: String

enum class DescriptionCollectionAssertion : StringBasedTranslatable

EMPTY
HAS_SIZE
val value: String

enum class DescriptionCollectionAssertion : StringBasedTranslatable

EMPTY
val value: String

enum class DescriptionComparableAssertion : StringBasedTranslatable

IS_GREATER_OR_EQUALS
IS_GREATER_THAN
IS_LESS_OR_EQUALS
IS_LESS_THAN
val value: String

enum class DescriptionComparableAssertion : StringBasedTranslatable

IS_GREATER_OR_EQUALS
IS_GREATER_THAN
IS_LESS_OR_EQUALS
IS_LESS_THAN
val value: String

enum class DescriptionFloatingPointAssertion : StringBasedTranslatable

FAILURE_DUE_TO_FLOATING_POINT_NUMBER
TO_BE_WITH_ERROR_TOLERANCE
TO_BE_WITH_ERROR_TOLERANCE_EXPLAINED
val value: String

enum class DescriptionFloatingPointAssertion : StringBasedTranslatable

FAILURE_DUE_TO_FLOATING_POINT_NUMBER
TO_BE_WITH_ERROR_TOLERANCE
TO_BE_WITH_ERROR_TOLERANCE_EXPLAINED
val value: String

enum class DescriptionIterableAssertion : StringBasedTranslatable

AN_ENTRY_WHICH
AN_ENTRY_WHICH_IS
AT_LEAST
AT_MOST
CANNOT_EVALUATE_SUBJECT_EMPTY_ITERABLE
CANNOT_EVALUATE_SUBJECT_ONLY_NULL
CONTAINS
CONTAINS_NOT
ENTRY_WITH_INDEX
EXACTLY
IN_ANY_ORDER
IN_ANY_ORDER_ONLY
IN_ORDER
IN_ORDER_ONLY
NUMBER_OF_OCCURRENCES
SIZE_EXCEEDED
WARNING_ADDITIONAL_ENTRIES
WARNING_MISMATCHES
WARNING_MISMATCHES_ADDITIONAL_ENTRIES
val value: String

enum class DescriptionIterableAssertion : StringBasedTranslatable

ALL
AN_ENTRY_WHICH
AN_ENTRY_WHICH_IS
AT_LEAST
AT_MOST
CANNOT_EVALUATE_SUBJECT_EMPTY_ITERABLE
CANNOT_EVALUATE_SUBJECT_ONLY_NULL
CONTAINS
CONTAINS_NOT
ENTRY_WITH_INDEX
EXACTLY
HAS_ELEMENT
INDEX
INDEX_FROM_TO
IN_ANY_ORDER
IN_ANY_ORDER_ONLY
IN_ORDER
IN_ORDER_ONLY
IN_ORDER_ONLY_GROUPED
NUMBER_OF_OCCURRENCES
SIZE_EXCEEDED
WARNING_ADDITIONAL_ENTRIES
WARNING_MISMATCHES
WARNING_MISMATCHES_ADDITIONAL_ENTRIES
val value: String

enum class DescriptionMapAssertion : StringBasedTranslatable

EMPTY
val value: String

enum class DescriptionThrowableAssertion : StringBasedTranslatable

IS_A
NO_EXCEPTION_OCCURRED
val value: String

enum class DescriptionThrowableAssertion : StringBasedTranslatable

IS_A
NO_EXCEPTION_OCCURRED
OCCURRED_EXCEPTION_MESSAGE
OCCURRED_EXCEPTION_PROPERTIES
OCCURRED_EXCEPTION_STACKTRACE
val value: String

enum class DescriptionTypeTransformationAssertion : StringBasedTranslatable

IS_A
WARNING_DOWN_CAST_FAILED
val value: String

enum class DescriptionTypeTransformationAssertion : StringBasedTranslatable

IS_A
WARNING_DOWN_CAST_FAILED
val value: String

interface DescriptiveAssertion : Assertion

abstract val description: Translatable
open val expected: Any
abstract val representation: Any

interface DescriptiveAssertionFinalStep : AssertionBuilderFinalStep<DescriptiveAssertion>

fun create(test: () -> Boolean, description: Translatable, representation: Any): DescriptiveAssertionFinalStep
abstract val description: Translatable
abstract val representation: Any
abstract val test: () -> Boolean

interface DescriptiveAssertionHoldsOption

abstract val failing: DescriptiveLikeAssertionDescriptionOption<DescriptiveAssertionFinalStep>
abstract val holding: DescriptiveLikeAssertionDescriptionOption<DescriptiveAssertionFinalStep>
abstract fun withTest(test: () -> Boolean): DescriptiveLikeAssertionDescriptionOption<DescriptiveAssertionFinalStep>

interface DescriptiveAssertionWithFailureHintFinalStep : AssertionBuilderFinalStep<Assertion>

fun create(test: () -> Boolean, showHint: () -> Boolean, failureHintFactory: () -> Assertion, description: Translatable, representation: Any): DescriptiveAssertionWithFailureHintFinalStep
abstract val description: Translatable
abstract val failureHintFactory: () -> Assertion
abstract val representation: Any
abstract val showHint: () -> Boolean
abstract val test: () -> Boolean

interface DescriptiveAssertionWithFailureHintShowOption

fun create(test: () -> Boolean, failureHintFactory: () -> Assertion): DescriptiveAssertionWithFailureHintShowOption
abstract val showForAnyFailure: DescriptiveLikeAssertionDescriptionOption<DescriptiveAssertionWithFailureHintFinalStep>
abstract fun showOnlyIf(predicate: () -> Boolean): DescriptiveLikeAssertionDescriptionOption<DescriptiveAssertionWithFailureHintFinalStep>

interface DescriptiveLikeAssertionDescriptionOption<R>

fun <R> create(test: () -> Boolean, factory: (() -> Boolean, Translatable, Any) -> R): DescriptiveLikeAssertionDescriptionOption<R>
abstract val test: () -> Boolean
open fun withDescriptionAndNullableRepresentation(description: Translatable, representation: Any?): R
abstract fun withDescriptionAndRepresentation(description: Translatable, representation: Any): R

interface DoNotFilterAssertionGroupType : AssertionGroupType
class DownCaster<T : Any, TSub : T>

DownCaster(failureHandler: TypeTransformationFailureHandler<T, TSub>)
fun downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit

class Eintraege<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>

Eintraege(assertionCreator: Assert<T>.() -> Unit, vararg otherAssertionCreators: Assert<T>.() -> Unit)
val assertionCreator: Assert<T>.() -> Unit
vararg val otherAssertionCreators: Array<Assert<T>.() -> Unit>
fun toList(): List<Assert<T>.() -> Unit>

class Eintrag<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>

Eintrag(assertionCreator: Assert<T>.() -> Unit)
val assertionCreator: Assert<T>.() -> Unit
fun toList(): List<Assert<T>.() -> Unit>

object Empty
object Empty
open class EmptyNameAndRepresentationAssertionGroup : AssertionGroup

EmptyNameAndRepresentationAssertionGroup(type: AssertionGroupType, assertions: List<Assertion>)
open val assertions: List<Assertion>
open val description: Translatable
open val representation: Any
open val type: AssertionGroupType

class Entries<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>

Entries(assertionCreator: Assert<T>.() -> Unit, vararg otherAssertionCreators: Assert<T>.() -> Unit)
val assertionCreator: Assert<T>.() -> Unit
vararg val otherAssertionCreators: Array<Assert<T>.() -> Unit>
fun toList(): List<Assert<T>.() -> Unit>

class Entries<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>

Entries(assertionCreator: Assert<T>.() -> Unit, vararg otherAssertionCreators: Assert<T>.() -> Unit)
val assertionCreator: Assert<T>.() -> Unit
vararg val otherAssertionCreators: Array<Assert<T>.() -> Unit>
fun toList(): List<Assert<T>.() -> Unit>

class Entries<in T : Any, out A : (Assert<T>) -> Unit>

Entries(assertionCreator: A, vararg otherAssertionCreators: A)
val assertionCreator: A
vararg val otherAssertionCreators: Array<out A>
fun toList(): List<A>

class Entry<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>

Entry(assertionCreator: Assert<T>.() -> Unit)
val assertionCreator: Assert<T>.() -> Unit
fun toList(): List<Assert<T>.() -> Unit>

class Entry<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>

Entry(assertionCreator: Assert<T>.() -> Unit)
val assertionCreator: Assert<T>.() -> Unit
fun toList(): List<Assert<T>.() -> Unit>

interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class ExactlyCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>

ExactlyCheckerOptionBase(times: Int, containsBuilder: Builder<T, S>, nameContainsNotFun: String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<T, S>
val times: Int

abstract class ExactlyCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>

ExactlyCheckerOptionBase(times: Int, containsBuilder: Builder<E, T, S>, nameContainsNotFun: String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<E, T, S>
val times: Int

open class ExactlyCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionBase<T, S>, ExactlyCheckerOption<T, S>

ExactlyCheckerOptionImpl(times: Int, containsBuilder: Builder<T, S>)

open class ExactlyCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ExactlyCheckerOptionBase<E, T, S>, ExactlyCheckerOption<E, T, S>

ExactlyCheckerOptionImpl(times: Int, containsBuilder: Builder<E, T, S>)

open class ExactlyCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionBase<T, S>, ExactlyCheckerOption<T, S>

ExactlyCheckerOptionImpl(times: Int, containsBuilder: Builder<T, S>)

open class ExactlyCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ExactlyCheckerOptionBase<E, T, S>, ExactlyCheckerOption<E, T, S>

ExactlyCheckerOptionImpl(times: Int, containsBuilder: Builder<E, T, S>)

object ExplainingAssertionCollectorOption

inline val doNotThrowIfNoAssertionIsCollected: NonThrowingAssertionCollectorForExplanation
inline val throwIfNoAssertionIsCollected: ThrowingAssertionCollectorForExplanation

interface ExplanatoryAssertion : Assertion

abstract val explanation: Any?
open fun holds(): Boolean

interface ExplanatoryAssertionExplanationOption

open fun withDescription(translatable: Translatable, arg: Any, vararg otherArgs: Any): ExplanatoryAssertionFinalStep
open fun withDescription(translatable: Translatable): ExplanatoryAssertionFinalStep
abstract fun withDescription(explanation: Any?): ExplanatoryAssertionFinalStep

interface ExplanatoryAssertionFinalStep : AssertionBuilderFinalStep<ExplanatoryAssertion>

fun create(explanation: Any?): ExplanatoryAssertionFinalStep
abstract val explanation: Any?

class ExplanatoryAssertionGroup : EmptyNameAndRepresentationAssertionGroup

fun holds(): Boolean

interface ExplanatoryAssertionGroupFinalStep : AssertionBuilderFinalStep<AssertionGroup>

fun create(groupType: ExplanatoryAssertionGroupType, explanatoryAssertions: List<Assertion>): ExplanatoryAssertionGroupFinalStep
abstract val explanatoryAssertions: List<Assertion>
abstract val groupType: ExplanatoryAssertionGroupType

interface ExplanatoryAssertionGroupType : DoNotFilterAssertionGroupType
interface ExplanatoryAssertionGroupTypeOption

abstract val withDefaultType: AssertionsOption<DefaultExplanatoryAssertionGroupType, ExplanatoryAssertionGroupFinalStep>
abstract fun <T : ExplanatoryAssertionGroupType> withType(groupType: T): AssertionsOption<T, ExplanatoryAssertionGroupFinalStep>
abstract val withWarningType: AssertionsOption<WarningAssertionGroupType, ExplanatoryAssertionGroupFinalStep>

class ExplanatoryTypeTransformationFailureHandler<T : Any, out TSub : T> : TypeTransformationFailureHandler<T, TSub>

ExplanatoryTypeTransformationFailureHandler()
fun createAndAddAssertionToPlant(warningTransformationFailed: Translatable, subjectPlant: BaseAssertionPlant<T?, *>, failingAssertion: Assertion, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit

interface FailureHandlerFactory

abstract fun <S : Any, T : Any> newExplanatory(): FailureHandler<S, T>
abstract fun <S : Any, T : Any> newExplanatoryWithHint(showHint: () -> Boolean, failureHintFactory: () -> Assertion): FailureHandler<S, T>

interface FeatureAssertionGroupType : AssertionGroupType
interface FeatureAssertions

abstract fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, name: Translatable): AssertionPlant<TProperty>
abstract fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, representationProvider: () -> Any?, name: Translatable): AssertionPlant<TProperty>
abstract fun <T : Any, TProperty> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, name: Translatable): AssertionPlantNullable<TProperty>
abstract fun <T : Any, TProperty> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, representationProvider: () -> Any?, name: Translatable): AssertionPlantNullable<TProperty>
abstract fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, name: String): AssertionPlant<R>
abstract fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>

object FeatureAssertionsBuilder : FeatureAssertions

inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable): AssertionPlantNullable<TProperty>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>

interface FixedClaimAssertionGroupFinalStep : BasicAssertionGroupFinalStep

fun create(groupType: AssertionGroupType, description: Translatable, representation: Any, assertions: List<Assertion>, holds: Boolean): FixedClaimAssertionGroupFinalStep
abstract val holds: Boolean

interface FixedClaimAssertionGroupHoldsOption<T : AssertionGroupType>

fun <T : AssertionGroupType> create(groupType: T): FixedClaimAssertionGroupHoldsOption<T>
abstract val failing: AssertionGroupDescriptionAndRepresentationOption<T, AssertionsOption<T, FixedClaimAssertionGroupFinalStep>>
abstract val groupType: T
abstract val holding: AssertionGroupDescriptionAndRepresentationOption<T, AssertionsOption<T, FixedClaimAssertionGroupFinalStep>>
abstract fun withClaim(holds: Boolean): AssertionGroupDescriptionAndRepresentationOption<T, AssertionsOption<T, FixedClaimAssertionGroupFinalStep>>

interface FixedClaimAssertionGroupTypeOption

abstract val withListType: FixedClaimAssertionGroupHoldsOption<ListAssertionGroupType>
abstract fun <T : AssertionGroupType> withType(type: T): FixedClaimAssertionGroupHoldsOption<T>

interface FloatingPointAssertions

abstract fun toBeWithErrorTolerance(plant: AssertionPlant<Float>, expected: Float, tolerance: Float): Assertion
abstract fun toBeWithErrorTolerance(plant: AssertionPlant<Double>, expected: Double, tolerance: Double): Assertion
abstract fun <T : BigDecimal> toBeWithErrorTolerance(plant: AssertionPlant<T>, expected: T, tolerance: T): Assertion

object FloatingPointAssertionsBuilder : FloatingPointAssertions

inline fun toBeWithErrorTolerance(plant: AssertionPlant<Float>, expected: Float, tolerance: Float): <ERROR CLASS>
inline fun toBeWithErrorTolerance(plant: AssertionPlant<Double>, expected: Double, tolerance: Double): <ERROR CLASS>
inline fun <T : BigDecimal> toBeWithErrorTolerance(plant: AssertionPlant<T>, expected: T, tolerance: T): <ERROR CLASS>

class ForgivingTest

ForgivingTest(test: <ERROR CLASS>)
fun execute(context: <ERROR CLASS>, dynamicTestExecutor: <ERROR CLASS>?): <ERROR CLASS>
fun getType(): <ERROR CLASS>
val parent: <ERROR CLASS>

interface Group<out T>

abstract fun toList(): List<T>

interface GroupWithNullableEntries<out T> : Group<T>
interface GroupWithoutNullableEntries<out T : Any> : Group<T>
interface IAtriumFactory

abstract fun newAssertionFormatterController(): AssertionFormatterController
abstract fun newAssertionFormatterFacade(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacade
abstract fun <T : Any> newCheckingPlant(subject: T): CheckingAssertionPlant<T>
abstract fun <T : Any> newCollectingPlant(subjectProvider: () -> T): CollectingAssertionPlant<T>
abstract fun <T> newDelegatingAssertionChecker(subjectPlant: BaseAssertionPlant<T, *>): AssertionChecker
abstract fun newDetailedObjectFormatter(translator: Translator): ObjectFormatter
abstract fun <T : Any> newFeatureAssertionChecker(subjectPlant: AssertionPlant<T>): AssertionChecker
abstract fun newLocaleOrderDecider(): LocaleOrderDecider
abstract fun newMethodCallFormatter(): MethodCallFormatter
abstract fun newOnlyFailureReporter(assertionFormatterFacade: AssertionFormatterFacade): Reporter
abstract fun newPropertiesBasedTranslationSupplier(): TranslationSupplier
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subject: T, reporter: Reporter): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subject: T, assertionChecker: AssertionChecker): ReportingAssertionPlant<T>
abstract fun <T : Any> newReportingPlant(commonFields: CommonFields<T>): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlantAndAddAssertionsCreatedBy(assertionVerb: Translatable, subject: T, reporter: Reporter, assertionCreator: AssertionPlant<T>.() -> Unit): AssertionPlant<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subject: T, reporter: Reporter, nullRepresentation: Any = RawString.NULL): ReportingAssertionPlantNullable<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subject: T, assertionChecker: AssertionChecker, nullRepresentation: Any): ReportingAssertionPlantNullable<T>
abstract fun <T> newReportingPlantNullable(commonFields: CommonFields<T>): ReportingAssertionPlantNullable<T>
abstract fun newTextExplanatoryAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController): AssertionFormatter
abstract fun newTextFallbackAssertionFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextFeatureAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextListAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextSameLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newThrowingAssertionChecker(reporter: Reporter): AssertionChecker
abstract fun newTranslator(translationSupplier: TranslationSupplier, localeOrderDecider: LocaleOrderDecider, primaryLocale: Locale, vararg fallbackLocales: Locale): Translator
abstract fun registerTextAssertionFormatterCapabilities(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterFacade: AssertionFormatterFacade, textAssertionPairFormatter: AssertionPairFormatter, objectFormatter: ObjectFormatter, translator: Translator): Unit

interface IgnoringCaseSearchBehaviour : SearchBehaviour
interface InAnyOrderOnlySearchBehaviour : SearchBehaviour
interface InAnyOrderSearchBehaviour : SearchBehaviour
interface InOrderOnlyGroupedSearchBehaviour : SearchBehaviour
interface InOrderOnlyGroupedWithinSearchBehaviour : InOrderOnlyGroupedSearchBehaviour
interface InOrderOnlySearchBehaviour : SearchBehaviour
interface InOrderSearchBehaviour : SearchBehaviour
class IndentAssertionGroup : EmptyNameAndRepresentationAssertionGroup

IndentAssertionGroup(assertions: List<Assertion>)

interface IndentAssertionGroupType : AssertionGroupType
class InvisibleAssertionGroup : EmptyNameAndRepresentationAssertionGroup
object InvisibleAssertionGroupType : AssertionGroupType
interface IterableAssertions

abstract fun <E : Any, T : Iterable<E?>> all(plant: AssertionPlant<T>, assertionCreator: AssertionPlant<E>.() -> Unit): Assertion
abstract fun <E, T : Iterable<E>> containsBuilder(plant: AssertionPlant<T>): Builder<E, T, NoOpSearchBehaviour>
abstract fun <E, T : Iterable<E>> containsNotBuilder(plant: AssertionPlant<T>): Builder<E, T, NotSearchBehaviour>

object IterableAssertionsBuilder : IterableAssertions

inline fun <E : Any, T : Iterable<E?>> all(plant: AssertionPlant<T>, noinline assertionCreator: AssertionPlant<E>.() -> Unit): Assertion
inline val contains: IterableContainsAssertionsBuilder
inline fun <E, T : Iterable<E>> containsBuilder(plant: AssertionPlant<T>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> containsNotBuilder(plant: AssertionPlant<T>): <ERROR CLASS>

interface IterableContains

interface Checker : Checker, Checker
interface Creator<in T : Iterable<*>, in S> : Creator<T, S>, Creator<T, S>
interface SearchBehaviour : SearchBehaviour, SearchBehaviour

interface IterableContains

interface Builder<out E, out T : Iterable<E>, out S : SearchBehaviour> : Builder<T, S>
interface Checker : Checker
interface CheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<T, S, Checker, Builder<E, T, S>>
interface Creator<in T : Iterable<*>, in SC> : Creator<T, SC>
interface SearchBehaviour : SearchBehaviour

interface IterableContainsAssertions

abstract fun <E : Any, T : Iterable<E?>> entriesInAnyOrder(checkerOption: CheckerOption<E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInAnyOrderOnly(builder: Builder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInOrderOnly(builder: Builder<E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyGrouped(builder: Builder<E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<AssertionPlant<E>.() -> Unit>>): Assertion
abstract fun <E, T : Iterable<E>> valuesInAnyOrder(checkerOption: CheckerOption<E, T, InAnyOrderSearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInAnyOrderOnly(builder: Builder<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInOrderOnly(builder: Builder<E, T, InOrderOnlySearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>): Assertion

object IterableContainsAssertionsBuilder : IterableContainsAssertions

inline fun <E : Any, T : Iterable<E?>> entriesInAnyOrder(checkerOption: CheckerOption<E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): <ERROR CLASS>
inline fun <E : Any, T : Iterable<E?>> entriesInAnyOrderOnly(builder: Builder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): <ERROR CLASS>
inline fun <E : Any, T : Iterable<E?>> entriesInOrderOnly(builder: Builder<E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): <ERROR CLASS>
inline fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyGrouped(builder: Builder<E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<AssertionPlant<E>.() -> Unit>>): Assertion
inline val searchBehaviours: IterableContainsSearchBehaviourFactoryBuilder
inline fun <E, T : Iterable<E>> valuesInAnyOrder(checkerOption: CheckerOption<E, T, InAnyOrderSearchBehaviour>, expected: List<E>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> valuesInAnyOrderOnly(builder: Builder<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> valuesInOrderOnly(builder: Builder<E, T, InOrderOnlySearchBehaviour>, expected: List<E>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> valuesInOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>): Assertion

class IterableContainsAtLeastChecker : IterableContainsChecker

IterableContainsAtLeastChecker(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtLeastCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtLeastCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtLeastCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

abstract class IterableContainsAtLeastCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsAtLeastCheckerBuilderBase(times: Int, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, atLeastCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int

class IterableContainsAtMostChecker : IterableContainsChecker

IterableContainsAtMostChecker(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtMostCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtMostCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtMostCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

abstract class IterableContainsAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsAtMostCheckerBuilderBase(times: Int, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int

open class IterableContainsBuilder<out E, out T : Iterable<E>, out S : SearchBehaviour> : ContainsBuilder<T, S>, Builder<E, T, S>

IterableContainsBuilder(plant: AssertionPlant<T>, searchBehaviour: S)

open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

abstract class IterableContainsButAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsButAtMostCheckerBuilderBase(times: Int, atLeastBuilder: IterableContainsAtLeastCheckerBuilderBase<E, T, S>, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int

abstract class IterableContainsChecker : ContainsChecker, Checker

IterableContainsChecker(times: Int, correctCall: String, wrongCall: (Int) -> String)

interface IterableContainsCheckerBuilder<out E, out T : Iterable<E>, out S : SearchBehaviour> : ContainsCheckerBuilder<T, S, Checker, Builder<E, T, S>>, CheckerOption<E, T, S>
class IterableContainsExactlyChecker : IterableContainsChecker

IterableContainsExactlyChecker(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsExactlyCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsExactlyCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsExactlyCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

abstract class IterableContainsExactlyCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsExactlyCheckerBuilderBase(times: Int, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int

open class IterableContainsInAnyOrderEntriesAssertionCreator<E : Any, T : Iterable<E?>> : ContainsAssertionCreator<T, AssertionPlant<E>.() -> Unit, Checker>, Creator<T, AssertionPlant<E>.() -> Unit>

IterableContainsInAnyOrderEntriesAssertionCreator(searchBehaviour: IterableContainsInAnyOrderSearchBehaviour, checkers: List<Checker>)
protected fun createAssertionGroupForSearchCriteriaAssertions(assertions: List<Assertion>): AssertionGroup
protected fun searchAndCreateAssertion(plant: AssertionPlant<T>, searchCriterion: AssertionPlant<E>.() -> Unit, featureFactory: (Int, Translatable) -> AssertionGroup): AssertionGroup

class IterableContainsInAnyOrderObjectsAssertionCreator<S, T : Iterable<S>> : ContainsObjectsAssertionCreator<T, S, IterableContainsInAnyOrderSearchBehaviour, Checker>, Creator<T, S>

IterableContainsInAnyOrderObjectsAssertionCreator(searchBehaviour: IterableContainsInAnyOrderSearchBehaviour, checkers: List<Checker>)
protected val descriptionContains: DescriptionIterableAssertion
protected val descriptionNumberOfOccurrences: DescriptionIterableAssertion
protected fun search(plant: AssertionPlant<T>, searchCriterion: S): Int

abstract class IterableContainsInAnyOrderOnlyAssertionCreator<E, T : Iterable<E?>, SC> : Creator<T, SC>

IterableContainsInAnyOrderOnlyAssertionCreator(searchBehaviour: IterableContainsInAnyOrderOnlySearchBehaviour)
protected abstract fun createAssertionForSearchCriterionAndRemoveMatchFromList(searchCriterion: SC, list: MutableList<E?>): <ERROR CLASS><Boolean, Assertion>
fun createAssertionGroup(plant: AssertionPlant<T>, searchCriterion: SC, otherSearchCriteria: Array<out SC>): AssertionGroup
fun createAssertionGroup(plant: AssertionPlant<T>, searchCriteria: List<SC>): AssertionGroup

class IterableContainsInAnyOrderOnlyEntriesAssertionCreator<E : Any, T : Iterable<E?>> : IterableContainsInAnyOrderOnlyAssertionCreator<E, T, AssertionPlant<E>.() -> Unit>

IterableContainsInAnyOrderOnlyEntriesAssertionCreator(searchBehaviour: IterableContainsInAnyOrderOnlySearchBehaviour)
protected fun createAssertionForSearchCriterionAndRemoveMatchFromList(searchCriterion: AssertionPlant<E>.() -> Unit, list: MutableList<E?>): <ERROR CLASS><Boolean, Assertion>

class IterableContainsInAnyOrderOnlyObjectsAssertionCreator<E, T : Iterable<E?>> : IterableContainsInAnyOrderOnlyAssertionCreator<E, T, E>

IterableContainsInAnyOrderOnlyObjectsAssertionCreator(searchBehaviour: IterableContainsInAnyOrderOnlySearchBehaviour)
protected fun createAssertionForSearchCriterionAndRemoveMatchFromList(searchCriterion: E, list: MutableList<E?>): <ERROR CLASS><Boolean, Assertion>

open class IterableContainsInAnyOrderOnlySearchBehaviour : SearchBehaviour, InAnyOrderOnlySearchBehaviour

IterableContainsInAnyOrderOnlySearchBehaviour()
open fun decorateDescription(description: Translatable): Translatable

open class IterableContainsInAnyOrderSearchBehaviour : SearchBehaviour, InAnyOrderSearchBehaviour

IterableContainsInAnyOrderSearchBehaviour()
open fun decorateDescription(description: Translatable): Translatable

abstract class IterableContainsInOrderOnlyAssertionCreator<E, T : Iterable<E?>, SC> : Creator<T, SC>

IterableContainsInOrderOnlyAssertionCreator(searchBehaviour: IterableContainsInOrderOnlySearchBehaviour)
fun createAssertionGroup(plant: AssertionPlant<T>, searchCriterion: SC, otherSearchCriteria: Array<out SC>): AssertionGroup
fun createAssertionGroup(plant: AssertionPlant<T>, searchCriteria: List<SC>): AssertionGroup
abstract fun createEntryAssertion(iterableAsList: List<E?>, searchCriterion: SC, template: ((Boolean) -> Assertion) -> AssertionGroup): AssertionGroup
abstract fun matches(actual: E?, searchCriterion: SC): Boolean

class IterableContainsInOrderOnlyEntriesAssertionCreator<E : Any, T : Iterable<E?>> : IterableContainsInOrderOnlyAssertionCreator<E, T, AssertionPlant<E>.() -> Unit>

IterableContainsInOrderOnlyEntriesAssertionCreator(searchBehaviour: IterableContainsInOrderOnlySearchBehaviour)
fun createEntryAssertion(iterableAsList: List<E?>, searchCriterion: AssertionPlant<E>.() -> Unit, template: ((Boolean) -> Assertion) -> AssertionGroup): AssertionGroup
fun matches(actual: E?, searchCriterion: AssertionPlant<E>.() -> Unit): Boolean

class IterableContainsInOrderOnlyObjectsAssertionCreator<E, T : Iterable<E?>> : IterableContainsInOrderOnlyAssertionCreator<E, T, E>

IterableContainsInOrderOnlyObjectsAssertionCreator(searchBehaviour: IterableContainsInOrderOnlySearchBehaviour)
fun createEntryAssertion(iterableAsList: List<E?>, searchCriterion: E, template: ((Boolean) -> Assertion) -> AssertionGroup): AssertionGroup
fun matches(actual: E?, searchCriterion: E): Boolean

open class IterableContainsInOrderOnlySearchBehaviour : SearchBehaviour, InOrderOnlySearchBehaviour

IterableContainsInOrderOnlySearchBehaviour()
open fun decorateDescription(description: Translatable): Translatable

open class IterableContainsInOrderSearchBehaviour : SearchBehaviour, InOrderSearchBehaviour

IterableContainsInOrderSearchBehaviour()
open fun decorateDescription(description: Translatable): Translatable

class IterableContainsNoOpCheckerBuilder<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsNoOpCheckerBuilder(containsBuilder: IterableContainsBuilder<E, T, S>)
val checkers: List<Checker>
val containsBuilder: IterableContainsBuilder<E, T, S>

open class IterableContainsNoOpSearchBehaviour : SearchBehaviour, NoOpSearchBehaviour

IterableContainsNoOpSearchBehaviour()

class IterableContainsNotChecker : Checker

IterableContainsNotChecker()
fun createAssertion(foundNumberOfTimes: Int): Assertion

open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotCheckerBuilder(containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotCheckerBuilder(containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotCheckerBuilder(containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

abstract class IterableContainsNotCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsNotCheckerBuilderBase(containsBuilder: IterableContainsBuilder<E, T, S>)
open val checkers: <ERROR CLASS>
open val containsBuilder: IterableContainsBuilder<E, T, S>

open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

abstract class IterableContainsNotOrAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsNotOrAtMostCheckerBuilderBase(times: Int, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, notOrAtMostCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int

open class IterableContainsNotSearchBehaviour : IterableContainsInAnyOrderSearchBehaviour, NotSearchBehaviour

IterableContainsNotSearchBehaviour()
open fun decorateDescription(description: Translatable): Translatable

object IterableContainsSearchBehaviourFactoryBuilder : SearchBehaviourFactory

inline fun <E, T : Iterable<E>> inAnyOrder(builder: Builder<E, T, NoOpSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inAnyOrderOnly(builder: Builder<E, T, InAnyOrderSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrder(builder: Builder<E, T, NoOpSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrderOnly(builder: Builder<E, T, InOrderSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlySearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrderOnlyGroupedWithin(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>): <ERROR CLASS>

class LazyRepresentation

LazyRepresentation(provider: () -> Any)
fun eval(): Any

interface ListAssertionGroupType : AssertionGroupType
interface LocaleOrderDecider

abstract fun determineOrder(primaryLocale: Locale, fallbackLocales: List<Locale>): <ERROR CLASS><Locale>

interface LocaleOrderDeciderOption

fun create(translationSupplier: TranslationSupplier): LocaleOrderDeciderOption
abstract val translationSupplier: TranslationSupplier
abstract fun withDefaultLocaleOrderDecider(): TranslatorOption
abstract fun withLocaleOrderDecider(localeOrderDecider: LocaleOrderDecider): TranslatorOption

interface MapAssertions

abstract fun <T : Map<*, *>> hasSize(plant: AssertionPlant<T>, size: Int): Assertion
abstract fun <T : Map<*, *>> isEmpty(plant: AssertionPlant<T>): Assertion
abstract fun <T : Map<*, *>> isNotEmpty(plant: AssertionPlant<T>): Assertion

object MapAssertionsBuilder : MapAssertions

inline fun <T : Map<*, *>> hasSize(plant: AssertionPlant<T>, size: Int): <ERROR CLASS>
inline fun <T : Map<*, *>> isEmpty(plant: AssertionPlant<T>): <ERROR CLASS>
inline fun <T : Map<*, *>> isNotEmpty(plant: AssertionPlant<T>): <ERROR CLASS>

interface MethodCallFormatter

abstract fun format(name: String, arguments: Array<out Any?>): () -> String

interface NoOpSearchBehaviour : SearchBehaviour

open fun decorateDescription(description: Translatable): Translatable

interface NoOpSearchBehaviour : SearchBehaviour

open fun decorateDescription(description: Translatable): Translatable

interface NonThrowingAssertionCollectorForExplanation

abstract fun <E : Any> collect(warning: Translatable, assertionCreator: AssertionPlant<E>.() -> Unit, subject: E?): List<Assertion>

interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
abstract class NotCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>

NotCheckerOptionBase(containsBuilder: Builder<T, S>)
open val checkers: <ERROR CLASS>
open val containsBuilder: Builder<T, S>

abstract class NotCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>

NotCheckerOptionBase(containsBuilder: Builder<E, T, S>)
open val checkers: <ERROR CLASS>
open val containsBuilder: Builder<E, T, S>

open class NotCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionBase<T, S>, NotCheckerOption<T, S>

NotCheckerOptionImpl(containsBuilder: Builder<T, S>)

open class NotCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotCheckerOptionBase<E, T, S>, NotCheckerOption<E, T, S>

NotCheckerOptionImpl(containsBuilder: Builder<E, T, S>)

open class NotCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionBase<T, S>, NotCheckerOption<T, S>

NotCheckerOptionImpl(containsBuilder: Builder<T, S>)

open class NotCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotCheckerOptionBase<E, T, S>, NotCheckerOption<E, T, S>

NotCheckerOptionImpl(containsBuilder: Builder<E, T, S>)

interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class NotOrAtMostCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>

NotOrAtMostCheckerOptionBase(times: Int, containsBuilder: Builder<T, S>, nameContainsNotFun: String, notOrAtMostCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<T, S>
val times: Int

abstract class NotOrAtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>

NotOrAtMostCheckerOptionBase(times: Int, containsBuilder: Builder<E, T, S>, nameContainsNotFun: String, notOrAtMostCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<E, T, S>
val times: Int

open class NotOrAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionBase<T, S>, NotOrAtMostCheckerOption<T, S>

NotOrAtMostCheckerOptionImpl(times: Int, containsBuilder: Builder<T, S>)

open class NotOrAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotOrAtMostCheckerOptionBase<E, T, S>, NotOrAtMostCheckerOption<E, T, S>

NotOrAtMostCheckerOptionImpl(times: Int, containsBuilder: Builder<E, T, S>)

open class NotOrAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionBase<T, S>, NotOrAtMostCheckerOption<T, S>

NotOrAtMostCheckerOptionImpl(times: Int, containsBuilder: Builder<T, S>)

open class NotOrAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotOrAtMostCheckerOptionBase<E, T, S>, NotOrAtMostCheckerOption<E, T, S>

NotOrAtMostCheckerOptionImpl(times: Int, containsBuilder: Builder<E, T, S>)

interface NotSearchBehaviour : NoOpSearchBehaviour
interface NotSearchBehaviour : InAnyOrderSearchBehaviour
class NullableEintraege<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>

NullableEintraege(assertionCreatorOrNull: Assert<T>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<T>.() -> Unit)
val assertionCreatorOrNull: Assert<T>.() -> Unit
vararg val otherAssertionCreatorsOrNulls: Array<Assert<T>.() -> Unit>
fun toList(): List<Assert<T>.() -> Unit>

class NullableEintrag<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>

NullableEintrag(assertionCreator: Assert<T>.() -> Unit)
val assertionCreator: Assert<T>.() -> Unit
fun toList(): List<Assert<T>.() -> Unit>

class NullableEntries<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>

NullableEntries(assertionCreatorOrNull: Assert<T>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<T>.() -> Unit)
val assertionCreatorOrNull: Assert<T>.() -> Unit
vararg val otherAssertionCreatorsOrNulls: Array<Assert<T>.() -> Unit>
fun toList(): List<Assert<T>.() -> Unit>

class NullableEntries<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>

NullableEntries(assertionCreatorOrNull: Assert<T>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<T>.() -> Unit)
val assertionCreatorOrNull: Assert<T>.() -> Unit
vararg val otherAssertionCreatorsOrNulls: Array<Assert<T>.() -> Unit>
fun toList(): List<Assert<T>.() -> Unit>

class NullableEntry<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>

NullableEntry(assertionCreator: Assert<T>.() -> Unit)
val assertionCreator: Assert<T>.() -> Unit
fun toList(): List<Assert<T>.() -> Unit>

class NullableEntry<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>

NullableEntry(assertionCreator: Assert<T>.() -> Unit)
val assertionCreator: Assert<T>.() -> Unit
fun toList(): List<Assert<T>.() -> Unit>

data class NullableValue<T> : GroupWithNullableEntries<T>

NullableValue(expected: T)
val expected: T
fun toList(): <ERROR CLASS>

class NullableValue<out T> : GroupWithNullableEntries<T>

NullableValue(expected: T)
val expected: T
fun toList(): List<T>

class NullableValues<T> : GroupWithNullableEntries<T>

NullableValues(expected: T, vararg otherExpected: T)
vararg val otherExpected: Array<out T>
fun toList(): <ERROR CLASS>

class NullableValues<out T> : GroupWithNullableEntries<T>

NullableValues(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>
fun toList(): List<T>

data class NullableWert<T> : GroupWithNullableEntries<T>

NullableWert(expected: T)
val expected: T
fun toList(): <ERROR CLASS>

class NullableWerte<T> : GroupWithNullableEntries<T>

NullableWerte(expected: T, vararg otherExpected: T)
vararg val otherExpected: Array<out T>
fun toList(): <ERROR CLASS>

interface ObjectFormatter

abstract fun format(value: Any?): String

interface ObjectFormatterOption

fun create(translator: Translator): ObjectFormatterOption
abstract val translator: Translator
abstract fun withDetailedObjectFormatter(): AssertionFormatterControllerOption
abstract fun withObjectFormatter(factory: (Translator) -> ObjectFormatter): AssertionFormatterControllerOption

class Objects<out T>

Objects(values: Values<T>)
Objects(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>

class Order<T, G : Group<T>>

Order(firstGroup: G, secondGroup: G, vararg otherExpectedGroups: G)
val firstGroup: G
vararg val otherExpectedGroups: Array<out G>
val secondGroup: G

class PlantHasNoSubjectException : RuntimeException

PlantHasNoSubjectException()
PlantHasNoSubjectException(message: String)

class PleaseUseReplacementException : Exception

PleaseUseReplacementException(reason: String)

class PrefixFailingSummaryAssertion : BulletPointIdentifier
class PrefixFeatureAssertionGroupHeader : BulletPointIdentifier
class PrefixSuccessfulSummaryAssertion : BulletPointIdentifier
interface RawString

val EMPTY: RawString
val NULL: StringBasedRawString
fun create(string: String): RawString
fun create(translatable: Translatable): RawString

class RegexPatterns

RegexPatterns(pattern: String, vararg otherPatterns: String)
vararg val otherPatterns: Array<out String>
val pattern: String
fun toList(): List<String>

class RegexPatterns

RegexPatterns(pattern: String, vararg otherPatterns: String)
vararg val otherPatterns: Array<out String>
val pattern: String
fun toList(): List<String>

interface Reporter

abstract fun format(assertion: Assertion, sb: StringBuilder): Unit

class ReporterBuilder

ReporterBuilder(assertionFormatterFacade: AssertionFormatterFacade)
class AssertionFormatterChosenOptions

AssertionFormatterChosenOptions(assertionFormatterFacade: AssertionFormatterFacade, objectFormatter: ObjectFormatter, translator: Translator)
val assertionFormatterFacade: AssertionFormatterFacade
val objectFormatter: ObjectFormatter
val translator: Translator

class AssertionFormatterControllerOptions

AssertionFormatterControllerOptions(objectFormatter: ObjectFormatter, translator: Translator)
fun withAssertionFormatterController(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacadeOptions
fun withDefaultAssertionFormatterController(): AssertionFormatterFacadeOptions

class AssertionFormatterFacadeOptions

AssertionFormatterFacadeOptions(assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator)
fun withAssertionFormatterFacade(factory: (AssertionFormatterController) -> AssertionFormatterFacade): AssertionPairFormatterOptions
fun withDefaultAssertionFormatterFacade(): AssertionPairFormatterOptions

class AssertionPairFormatterOptions

AssertionPairFormatterOptions(options: AssertionFormatterChosenOptions)
fun withSameLineTextAssertionFormatter(vararg bulletPoints: <ERROR CLASS><Class<out BulletPointIdentifier>, String>): ReporterBuilder
fun withTextAssertionPairFormatter(factory: (ObjectFormatter, Translator) -> AssertionPairFormatter): TextAssertionFormatterOptions
fun withTextSameLineAssertionPairFormatter(): TextAssertionFormatterOptions

class LocaleOrderDeciderOptions

LocaleOrderDeciderOptions(translationSupplier: TranslationSupplier)
fun withDefaultLocaleOrderDecider(): TranslatorOptions
fun withLocaleOrderDecider(localeOrderDecider: LocaleOrderDecider): TranslatorOptions

class ObjectFormatterOptions

ObjectFormatterOptions(translator: Translator)
fun withDetailedObjectFormatter(): AssertionFormatterControllerOptions
fun withObjectFormatter(factory: (Translator) -> ObjectFormatter): AssertionFormatterControllerOptions

class TextAssertionFormatterOptions

TextAssertionFormatterOptions(options: AssertionFormatterChosenOptions, assertionPairFormatter: AssertionPairFormatter)
fun withDefaultTextCapabilities(vararg bulletPoints: <ERROR CLASS><Class<out BulletPointIdentifier>, String>): ReporterBuilder
fun withTextAssertionFormatter(factory: (AssertionFormatterChosenOptions) -> (AssertionFormatterController) -> AssertionFormatter, vararg otherFactories: (AssertionFormatterChosenOptions) -> (AssertionFormatterController) -> AssertionFormatter): ReporterBuilder

class TranslatorOptions

TranslatorOptions(translationSupplier: TranslationSupplier, localeOrderDecider: LocaleOrderDecider)
fun withDefaultTranslator(primaryLocale: Locale, vararg fallbackLocales: Locale): ObjectFormatterOptions
fun withTranslator(factory: (TranslationSupplier, LocaleOrderDecider) -> Translator): ObjectFormatterOptions

fun buildCustomReporter(factory: (AssertionFormatterFacade) -> Reporter): Reporter
fun buildOnlyFailureReporter(): Reporter
fun withDefaultTranslationSupplier(): LocaleOrderDeciderOptions
fun withTranslationSupplier(translationSupplier: TranslationSupplier): LocaleOrderDeciderOptions
fun withTranslator(translator: Translator): ObjectFormatterOptions
fun withoutTranslations(primaryLocale: Locale = Locale.getDefault()): ObjectFormatterOptions

interface ReporterBuilder

abstract fun withDefaultTranslationSupplier(): LocaleOrderDeciderOption
abstract fun withTranslationSupplier(translationSupplier: TranslationSupplier): LocaleOrderDeciderOption
abstract fun withTranslator(translator: Translator): ObjectFormatterOption
abstract fun withoutTranslations(primaryLocale: Locale = Locale.getDefault()): ObjectFormatterOption

interface ReporterBuilderFinalStep

abstract fun build(): Reporter
fun create(factory: () -> Reporter): ReporterBuilderFinalStep

interface ReporterFactory

const val SYSTEM_PROPERTY: String
abstract fun create(): Reporter
abstract val id: String
fun specifyFactory(reporterFactoryId: String): String
fun specifyFactoryIfNotYetSet(reporterFactoryId: String): Unit

interface ReporterOption

abstract val assertionFormatterFacade: AssertionFormatterFacade
fun create(assertionFormatterFacade: AssertionFormatterFacade): ReporterOption
abstract fun withCustomReporter(factory: (AssertionFormatterFacade) -> Reporter): ReporterBuilderFinalStep
abstract fun withOnlyFailureReporter(): ReporterBuilderFinalStep

interface ReportingAssertionPlant<out T : Any> : AssertionPlant<T>, BaseReportingAssertionPlant<T, AssertionPlant<T>>
interface ReportingAssertionPlantNullable<out T> : AssertionPlantNullable<T>, BaseReportingAssertionPlant<T, AssertionPlantNullable<T>>
object RootAssertionGroupType : AssertionGroupType
interface SearchBehaviourFactory

abstract fun <T : CharSequence> ignoringCase(containsBuilder: Builder<T, NoOpSearchBehaviour>): Builder<T, IgnoringCaseSearchBehaviour>

interface SearchBehaviourFactory

abstract fun <E, T : Iterable<E>> inAnyOrder(builder: Builder<E, T, NoOpSearchBehaviour>): Builder<E, T, InAnyOrderSearchBehaviour>
abstract fun <E, T : Iterable<E>> inAnyOrderOnly(builder: Builder<E, T, InAnyOrderSearchBehaviour>): Builder<E, T, InAnyOrderOnlySearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrder(builder: Builder<E, T, NoOpSearchBehaviour>): Builder<E, T, InOrderSearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnly(builder: Builder<E, T, InOrderSearchBehaviour>): Builder<E, T, InOrderOnlySearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlySearchBehaviour>): Builder<E, T, InOrderOnlyGroupedSearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnlyGroupedWithin(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>): Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>

object SingleServiceLoader

fun <T : Any> load(clazz: Class<T>): T

data class StringBasedRawString : RawString

val string: String

interface StringBasedTranslatable : Translatable

open fun getDefault(): String
abstract val value: String

interface SummaryAssertionGroupType : DoNotFilterAssertionGroupType
interface TextAssertionFormatterOption

abstract val assertionPairFormatter: AssertionPairFormatter
fun create(options: AssertionFormatterChosenOptions, assertionPairFormatter: AssertionPairFormatter): TextAssertionFormatterOption
abstract val options: AssertionFormatterChosenOptions
abstract fun withDefaultTextCapabilities(vararg bulletPoints: <ERROR CLASS><Class<out BulletPointIdentifier>, String>): ReporterOption
abstract fun withTextAssertionFormatter(factory: (AssertionFormatterChosenOptions) -> (AssertionFormatterController) -> AssertionFormatter, vararg otherFactories: (AssertionFormatterChosenOptions) -> (AssertionFormatterController) -> AssertionFormatter): ReporterOption

interface ThrowableAssertions

abstract fun thrownBuilder(assertionVerb: Translatable, act: () -> Unit, reporter: Reporter): Builder

object ThrowableAssertionsBuilder : ThrowableAssertions

inline val thrown: ThrowableThrownAssertionsBuilder
inline fun thrownBuilder(assertionVerb: Translatable, noinline act: () -> Unit, reporter: Reporter): Builder

interface ThrowableThrown

interface AbsentThrowableMessageProvider

abstract val message: RawString

interface Creator<TExpected : Throwable>

abstract fun executeActAndCreateAssertion(throwableThrownBuilder: ThrowableThrownBuilder, description: Translatable, expectedType: KClass<TExpected>, assertionCreator: AssertionPlant<TExpected>.() -> Unit): Unit

interface ThrowableThrown

interface AbsentThrowableMessageProvider

abstract val message: RawString

interface Builder

abstract val act: () -> Unit
abstract val assertionVerb: Translatable
abstract val reporter: Reporter

interface Creator<TExpected : Throwable>

abstract fun executeActAndCreateAssertion(throwableThrownBuilder: Builder, description: Translatable, expectedType: KClass<TExpected>, assertionCreator: AssertionPlant<TExpected>.() -> Unit): Unit

class ThrowableThrownAssertionCreator<TExpected : Throwable> : Creator<TExpected>

ThrowableThrownAssertionCreator(absentThrowableMessageProvider: AbsentThrowableMessageProvider, failureHandler: TypeTransformationFailureHandler<Throwable, TExpected>)
fun executeActAndCreateAssertion(throwableThrownBuilder: ThrowableThrownBuilder, description: Translatable, expectedType: KClass<TExpected>, assertionCreator: AssertionPlant<TExpected>.() -> Unit): Unit

interface ThrowableThrownAssertions

abstract fun <TExpected : Throwable> toBe(throwableThrownBuilder: Builder, expectedType: KClass<TExpected>, assertionCreator: AssertionPlant<TExpected>.() -> Unit): Unit

object ThrowableThrownAssertionsBuilder : ThrowableThrownAssertions

inline val providers: AbsentThrowableMessageProviderFactoryBuilder
inline fun <TExpected : Throwable> toBe(throwableThrownBuilder: Builder, expectedType: KClass<TExpected>, noinline assertionCreator: AssertionPlant<TExpected>.() -> Unit): <ERROR CLASS>

class ThrowableThrownBuilder : Builder

ThrowableThrownBuilder(assertionVerb: Translatable, act: () -> Unit, reporter: Reporter)
val act: () -> Unit
val assertionVerb: Translatable
val reporter: Reporter

interface ThrowingAssertionCollectorForExplanation

abstract fun <E : Any> collect(warning: Translatable, assertionCreator: AssertionPlant<E>.() -> Unit, subject: E?): List<Assertion>

interface Translatable

const val ID_SEPARATOR: String
abstract fun getDefault(): String
open val id: String
abstract val name: String

class TranslatableAsAbsentThrowableMessageProvider : AbsentThrowableMessageProvider

TranslatableAsAbsentThrowableMessageProvider(translatable: Translatable)
val message: RawString

data class TranslatableBasedRawString : RawString

val translatable: Translatable

class TranslatableWithArgs : Translatable

TranslatableWithArgs(translatable: Translatable, argument: Any)
TranslatableWithArgs(translatable: Translatable, arg1: Any, vararg otherArguments: Any)
TranslatableWithArgs(translatable: Translatable, arguments: Array<Any>)
val arguments: Array<Any>
fun getDefault(): <ERROR CLASS>
val id: <ERROR CLASS>
val name: String
val translatable: Translatable

interface TranslationSupplier

abstract fun get(translatable: Translatable, locale: Locale): String?

interface Translator

abstract fun translate(translatable: Translatable): String

interface TranslatorOption

abstract val localeOrderDecider: LocaleOrderDecider
abstract val translationSupplier: TranslationSupplier
abstract fun withDefaultTranslator(primaryLocale: Locale, vararg fallbackLocales: Locale): ObjectFormatterOption
abstract fun withTranslator(factory: (TranslationSupplier, LocaleOrderDecider) -> Translator): ObjectFormatterOption

class TypeTransformer<T : Any, TSub : Any>

TypeTransformer(failureHandler: TypeTransformationFailureHandler<T, TSub>)
fun transform(description: Translatable, representation: Any, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit, warningTransformationFailed: Translatable, canBeTransformed: (T) -> Boolean, transform: (T) -> TSub): Unit

class Untranslatable : Translatable

Untranslatable(representation: CharSequence)
Untranslatable(representation: () -> String)
val EMPTY: Untranslatable
fun getDefault(): String
val name: String

class UsingDefaultTranslator : ArgumentsSupportingTranslator

UsingDefaultTranslator(primaryLocale: Locale = Locale.getDefault())
protected fun translateWithoutArgs(translatable: Translatable): String

data class Value<T : Any> : GroupWithoutNullableEntries<T>

Value(expected: T)
val expected: T
fun toList(): <ERROR CLASS>

class Value<out T : Any> : GroupWithoutNullableEntries<T>

Value(expected: T)
val expected: T
fun toList(): List<T>

class Values<T : Any> : GroupWithoutNullableEntries<T>

Values(expected: T, vararg otherExpected: T)
vararg val otherExpected: Array<out T>
fun toList(): <ERROR CLASS>

class Values<out T : Any> : GroupWithoutNullableEntries<T>

Values(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>
fun toList(): List<T>

class Values<out T>

Values(objects: Objects<T>)
Values(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>
fun toList(): List<T>

object WarningAssertionGroupType : ExplanatoryAssertionGroupType
data class Wert<T : Any> : GroupWithoutNullableEntries<T>

Wert(expected: T)
val expected: T
fun toList(): <ERROR CLASS>

class Werte<T : Any> : GroupWithoutNullableEntries<T>

Werte(expected: T, vararg otherExpected: T)
vararg val otherExpected: Array<out T>
fun toList(): <ERROR CLASS>

interface WithTimesCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>

abstract val times: Int

interface WithTimesCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>

abstract val times: Int

object case
object case
object contain
object contain
object entries
object group
kotlin.Function0

fun <T> (() -> T).evalOnce(): () -> T

object only
object only
object order
object order

package ch.tutteli.atrium

interface IAtriumFactory

abstract fun newAssertionFormatterController(): AssertionFormatterController
abstract fun newAssertionFormatterFacade(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacade
abstract fun <T : Any> newCheckingPlant(subject: T): CheckingAssertionPlant<T>
abstract fun <T : Any> newCollectingPlant(subjectProvider: () -> T): CollectingAssertionPlant<T>
abstract fun <T> newDelegatingAssertionChecker(subjectPlant: BaseAssertionPlant<T, *>): AssertionChecker
abstract fun newDetailedObjectFormatter(translator: Translator): ObjectFormatter
abstract fun <T : Any> newFeatureAssertionChecker(subjectPlant: AssertionPlant<T>): AssertionChecker
abstract fun newLocaleOrderDecider(): LocaleOrderDecider
abstract fun newMethodCallFormatter(): MethodCallFormatter
abstract fun newOnlyFailureReporter(assertionFormatterFacade: AssertionFormatterFacade): Reporter
abstract fun newPropertiesBasedTranslationSupplier(): TranslationSupplier
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subject: T, reporter: Reporter): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subject: T, assertionChecker: AssertionChecker): ReportingAssertionPlant<T>
abstract fun <T : Any> newReportingPlant(commonFields: CommonFields<T>): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlantAndAddAssertionsCreatedBy(assertionVerb: Translatable, subject: T, reporter: Reporter, assertionCreator: AssertionPlant<T>.() -> Unit): AssertionPlant<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subject: T, reporter: Reporter, nullRepresentation: Any = RawString.NULL): ReportingAssertionPlantNullable<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subject: T, assertionChecker: AssertionChecker, nullRepresentation: Any): ReportingAssertionPlantNullable<T>
abstract fun <T> newReportingPlantNullable(commonFields: CommonFields<T>): ReportingAssertionPlantNullable<T>
abstract fun newTextExplanatoryAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController): AssertionFormatter
abstract fun newTextFallbackAssertionFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextFeatureAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextListAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextSameLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newThrowingAssertionChecker(reporter: Reporter): AssertionChecker
abstract fun newTranslator(translationSupplier: TranslationSupplier, localeOrderDecider: LocaleOrderDecider, primaryLocale: Locale, vararg fallbackLocales: Locale): Translator
abstract fun registerTextAssertionFormatterCapabilities(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterFacade: AssertionFormatterFacade, textAssertionPairFormatter: AssertionPairFormatter, objectFormatter: ObjectFormatter, translator: Translator): Unit

package ch.tutteli.atrium.api.cc.de_CH

object CharSequenceContainsSearchersKt

fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> standardUebersetzungVon(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> wert(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> werte(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>

class Eintraege<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>

Eintraege(assertionCreator: Assert<T>.() -> Unit, vararg otherAssertionCreators: Assert<T>.() -> Unit)
val assertionCreator: Assert<T>.() -> Unit
vararg val otherAssertionCreators: Array<Assert<T>.() -> Unit>
fun toList(): List<Assert<T>.() -> Unit>

class Eintrag<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>

Eintrag(assertionCreator: Assert<T>.() -> Unit)
val assertionCreator: Assert<T>.() -> Unit
fun toList(): List<Assert<T>.() -> Unit>

class NullableEintraege<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>

NullableEintraege(assertionCreatorOrNull: Assert<T>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<T>.() -> Unit)
val assertionCreatorOrNull: Assert<T>.() -> Unit
vararg val otherAssertionCreatorsOrNulls: Array<Assert<T>.() -> Unit>
fun toList(): List<Assert<T>.() -> Unit>

class NullableEintrag<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>

NullableEintrag(assertionCreator: Assert<T>.() -> Unit)
val assertionCreator: Assert<T>.() -> Unit
fun toList(): List<Assert<T>.() -> Unit>

data class NullableWert<T> : GroupWithNullableEntries<T>

NullableWert(expected: T)
val expected: T
fun toList(): <ERROR CLASS>

class NullableWerte<T> : GroupWithNullableEntries<T>

NullableWerte(expected: T, vararg otherExpected: T)
vararg val otherExpected: Array<out T>
fun toList(): <ERROR CLASS>

data class Wert<T : Any> : GroupWithoutNullableEntries<T>

Wert(expected: T)
val expected: T
fun toList(): <ERROR CLASS>

class Werte<T : Any> : GroupWithoutNullableEntries<T>

Werte(expected: T, vararg otherExpected: T)
vararg val otherExpected: Array<out T>
fun toList(): <ERROR CLASS>

fun <T : CharSequence, S : SearchBehaviour> AtLeastCheckerOption<T, S>.aberHoechstens(times: Int): ButAtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> aberHoechstens(checkerBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, times: Int): CharSequenceContainsButAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> AtLeastCheckerOption<E, T, S>.aberHoechstens(times: Int): ButAtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> aberHoechstens(checkerBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, times: Int): IterableContainsButAtMostCheckerBuilder<E, T>
fun <E : Any, T : Iterable<E>> Assert<T>.alle(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.alleDerNullable(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E> Assert<Array<E>>.asIterable(): AssertionPlant<Iterable<E>>
fun Assert<ByteArray>.asIterable(): AssertionPlant<Iterable<Byte>>
fun Assert<CharArray>.asIterable(): AssertionPlant<Iterable<Char>>
fun Assert<ShortArray>.asIterable(): AssertionPlant<Iterable<Short>>
fun Assert<IntArray>.asIterable(): AssertionPlant<Iterable<Int>>
fun Assert<LongArray>.asIterable(): AssertionPlant<Iterable<Long>>
fun Assert<FloatArray>.asIterable(): AssertionPlant<Iterable<Float>>
fun Assert<DoubleArray>.asIterable(): AssertionPlant<Iterable<Double>>
fun Assert<BooleanArray>.asIterable(): AssertionPlant<Iterable<Boolean>>
fun <E, T> Assert<T>.asIterable(): <ERROR CLASS>
fun <T : CharSequence> Assert<T>.beginntMit(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.beginntNichtMit(expected: CharSequence): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.eintraege(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintraege(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.eintraege(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintraege(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.eintraege(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintraege(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.eintrag(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintrag(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.eintrag(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintrag(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.eintrag(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintrag(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.endetMit(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.endetNichtMit(expected: CharSequence): AssertionPlant<T>
val <T : CharSequence> Assert<T>.enthaelt: Builder<T, NoOpSearchBehaviour>
fun <T : CharSequence> Assert<T>.enthaelt(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.enthaelt(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.enthaelt(assertionCreator: Assert<E>.() -> Unit): <ERROR CLASS>
fun <E : Any, T : Iterable<E>> Assert<T>.enthaelt(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
val <T : CharSequence> Assert<T>.enthaeltNicht: NotCheckerOption<T, NotSearchBehaviour>
fun <T : CharSequence> Assert<T>.enthaeltNicht(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.enthaeltNicht(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.enthaeltNichtDieStandardUebersetzungVon(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> enthaeltNullable(plant: Assert<T>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaeltNullableEintraege(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaeltNullableEintrag(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.enthaeltNullableWert(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.enthaeltNullableWerte(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.enthaeltRegex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.enthaeltStandardUebersetzungVon(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.enthaeltStrikt(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.enthaeltStrikt(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> enthaeltStriktNullable(plant: Assert<T>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaeltStriktNullableEintraege(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaeltStriktNullableEintrag(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.enthaeltStriktNullableWert(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.enthaeltStriktNullableWerte(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.genau(times: Int): ExactlyCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> genau(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsExactlyCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.genau(times: Int): ExactlyCheckerOption<E, T, S>
fun <E, T : Iterable<E>> genau(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsExactlyCheckerBuilder<E, T>
fun <T : CharSequence> getEnthaelt(plant: Assert<T>): CharSequenceContainsBuilder<T, NoOpSearchBehaviour>
fun <T : CharSequence> getEnthaeltNicht(plant: Assert<T>): CharSequenceContainsNotCheckerBuilder<T, NotSearchBehaviour>
fun <T : CharSequence> getIgnoriereGrossKleinschreibung(builder: CharSequenceContainsBuilder<T, NoOpSearchBehaviour>): CharSequenceContainsBuilder<T, IgnoringCaseSearchBehaviour>
fun <T : CharSequence> getIgnoriereGrossKleinschreibung(builder: CharSequenceContainsNotCheckerBuilder<T, NotSearchBehaviour>): CharSequenceContainsNotCheckerBuilder<T, IgnoringCaseSearchBehaviour>
fun <E, T : Iterable<E>> getInBeliebigerReihenfolge(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>): IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>
fun <E, T : Iterable<E>> getInGegebenerReihenfolge(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>): IterableContainsBuilder<E, T, InOrderSearchBehaviour>
val <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.gruppiert: <ERROR CLASS>
fun <T : Collection<*>> Assert<T>.hatDieGroesse(size: Int): AssertionPlant<T>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.hoechstens(times: Int): AtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> hoechstens(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.hoechstens(times: Int): AtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> hoechstens(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtMostCheckerBuilder<E, T>
val <T : CharSequence> Builder<T, NoOpSearchBehaviour>.ignoriereGrossKleinschreibung: Builder<T, IgnoringCaseSearchBehaviour>
val <T : CharSequence> NotCheckerOption<T, NotSearchBehaviour>.ignoriereGrossKleinschreibung: NotCheckerOption<T, IgnoringCaseSearchBehaviour>
fun <E, T : Iterable<E>> inAnyOrderOnly(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>): IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>
val <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inBeliebigerReihenfolge: <ERROR CLASS>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inBeliebigerReihenfolge(firstGroup: GroupWithoutNullableEntries<E>, secondGroup: GroupWithoutNullableEntries<E>, vararg otherExpectedGroups: GroupWithoutNullableEntries<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inBeliebigerReihenfolge(firstGroup: GroupWithNullableEntries<E>, secondGroup: GroupWithNullableEntries<E>, vararg otherExpectedGroups: GroupWithNullableEntries<E>): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inBeliebigerReihenfolge(firstGroup: GroupWithoutNullableEntries<Assert<E>.() -> Unit>, secondGroup: GroupWithoutNullableEntries<Assert<E>.() -> Unit>, vararg otherExpectedGroups: GroupWithoutNullableEntries<Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlyGroupedWithinSearchBehaviour>.inBeliebigerReihenfolge(firstGroup: GroupWithNullableEntries<Assert<E>.() -> Unit>, secondGroup: GroupWithNullableEntries<Assert<E>.() -> Unit>, vararg otherExpectedGroups: GroupWithNullableEntries<Assert<E>.() -> Unit>): AssertionPlant<T>
val <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inGegebenerReihenfolge: <ERROR CLASS>
fun <E, T : Iterable<E>> inOrderOnly(builder: IterableContainsBuilder<E, T, InOrderSearchBehaviour>): IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>
val <E, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedSearchBehaviour>.innerhalb: <ERROR CLASS>
fun <E : Any, T : Iterable<E?>> Assert<T>.irgendEinNullable(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.irgendEiner(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : Any> Assert<T>.ist(expected: T): AssertionPlant<T>
fun <T> AssertionPlantNullable<T>.ist(null: Nothing?): Unit
inline fun <reified TSub : Any> Assert<Any>.istEin(noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
fun Assert<Boolean>.istFalse(): AssertionPlant<Boolean>
fun <T : BigDecimal> Assert<T>.istGleichInklusiveScale(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.istGroesserAls(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.istGroesserOderGleich(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.istKleinerAls(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.istKleinerOderGleich(expected: T): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.istLeer(): AssertionPlant<T>
fun Assert<Float>.istMitFehlerToleranz(expected: Float, tolerance: Float): AssertionPlant<Float>
fun Assert<Double>.istMitFehlerToleranz(expected: Double, tolerance: Double): AssertionPlant<Double>
fun <T : BigDecimal> Assert<T>.istMitFehlerToleranz(expected: T, tolerance: T): AssertionPlant<T>
fun <T : Any> Assert<T>.istNicht(expected: T): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.istNichtGleichInklusiveScale(expected: T): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.istNichtLeer(): AssertionPlant<T>
inline fun <reified T : Any> AssertionPlantNullable<T?>.istNichtNull(noinline assertionCreator: Assert<T>.() -> Unit): Unit
inline fun <reified T : Any> AssertionPlantNullable<T?>.istNichtNullAber(expected: T): Unit
fun <T : BigDecimal> Assert<T>.istNichtNumerischGleichWie(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.istNichtSelbeInstanzWie(expected: T): AssertionPlant<T>
fun <T> AssertionPlantNullable<T>.istNull(): Unit
fun <T : BigDecimal> Assert<T>.istNumerischGleichWie(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.istSelbeInstanzWie(expected: T): AssertionPlant<T>
fun Assert<Boolean>.istTrue(): AssertionPlant<Boolean>
fun <E : Any, T : Iterable<E>> Assert<T>.keiner(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.keinerDerNullable(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : Throwable> Assert<T>.message(assertionCreator: Assert<String>.() -> Unit): Unit
fun <T : Throwable> Assert<T>.messageEnthaelt(expected: Any, vararg otherExpected: Any): Unit
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.nichtOderHoechstens(times: Int): NotOrAtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> nichtOderHoechstens(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsNotOrAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.nichtOderHoechstens(times: Int): NotOrAtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> nichtOderHoechstens(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsNotOrAtMostCheckerBuilder<E, T>
fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.nullableEintraege(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEintraege(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.nullableEintraege(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEintraege(checkerBuilder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.nullableEintraege(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEintraege(checkerBuilder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.nullableEintrag(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEintrag(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.nullableEintrag(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEintrag(checkerBuilder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.nullableEintrag(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEintrag(checkerBuilder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableWert(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableWert(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.nullableWert(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableWerte(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableWerte(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.nullableWerte(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
val <E, T : Iterable<E>> Builder<E, T, InAnyOrderSearchBehaviour>.nur: <ERROR CLASS>
val <E, T : Iterable<E>> Builder<E, T, InOrderSearchBehaviour>.nur: <ERROR CLASS>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.objekt(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekt(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.objekt(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekt(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.objekt(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekt(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.objekte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekte(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.objekte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekte(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.objekte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekte(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : Any, R : Any> Assert<T>.rueckgabewertVon(method: KFunction0<R>): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction0<R>): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.rueckgabewertVon(method: KFunction1<T, R>): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.rueckgabewertVon(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.rueckgabewertVon(method: KFunction1<T, R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.rueckgabewertVon(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.rueckgabewertVon(method: KFunction2<T, T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.rueckgabewertVon(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.rueckgabewertVon(method: KFunction2<T, T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.rueckgabewertVon(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.rueckgabewertVon(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.rueckgabewertVon(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.rueckgabewertVon(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.rueckgabewertVon(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.rueckgabewertVon(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.rueckgabewertVon(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.rueckgabewertVon(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.rueckgabewertVon(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.rueckgabewertVon(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.rueckgabewertVon(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.rueckgabewertVon(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.rueckgabewertVon(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.rueckgabewertVon(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.rueckgabewertVon(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.rueckgabewertVon(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.standardUebersetzungVon(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.standardUebersetzungVon(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
val <T : Any> AssertionPlant<T>.und: AssertionPlant<T>
infix fun <T : Any> AssertionPlant<T>.und(assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.wert(expected: Any): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.wert(expected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.wert(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> wert(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.wert(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> wert(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.wert(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> wert(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.werte(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.werte(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.werte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> werte(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.werte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> werte(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.werte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> werte(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
inline fun <reified TExpected : Throwable> Builder.wirft(): Unit
inline fun <reified TExpected : Throwable> Builder.wirft(noinline assertionCreator: Assert<TExpected>.() -> Unit): Unit
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.zumindest(times: Int): AtLeastCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> zumindest(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtLeastCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.zumindest(times: Int): AtLeastCheckerOption<E, T, S>
fun <E, T : Iterable<E>> zumindest(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtLeastCheckerBuilder<E, T>

package ch.tutteli.atrium.api.cc.de_CH.assertions.charsequence.contains.builders

open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtLeastCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtMostCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, containsBuilder: Builder<T, S>)

open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsExactlyCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotCheckerBuilder(containsBuilder: Builder<T, S>)

open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

package ch.tutteli.atrium.api.cc.de_CH.assertions.iterable.contains.builders

open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtLeastCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtMostCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsExactlyCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotCheckerBuilder(containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

package ch.tutteli.atrium.api.cc.de_CH.creating.charsequence.contains.builders

interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>

package ch.tutteli.atrium.api.cc.de_CH.creating.iterable.contains.builders

interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>

package ch.tutteli.atrium.api.cc.en_GB

class Entries<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>

Entries(assertionCreator: Assert<T>.() -> Unit, vararg otherAssertionCreators: Assert<T>.() -> Unit)
val assertionCreator: Assert<T>.() -> Unit
vararg val otherAssertionCreators: Array<Assert<T>.() -> Unit>
fun toList(): List<Assert<T>.() -> Unit>

class Entry<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>

Entry(assertionCreator: Assert<T>.() -> Unit)
val assertionCreator: Assert<T>.() -> Unit
fun toList(): List<Assert<T>.() -> Unit>

class NullableEntries<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>

NullableEntries(assertionCreatorOrNull: Assert<T>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<T>.() -> Unit)
val assertionCreatorOrNull: Assert<T>.() -> Unit
vararg val otherAssertionCreatorsOrNulls: Array<Assert<T>.() -> Unit>
fun toList(): List<Assert<T>.() -> Unit>

class NullableEntry<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>

NullableEntry(assertionCreator: Assert<T>.() -> Unit)
val assertionCreator: Assert<T>.() -> Unit
fun toList(): List<Assert<T>.() -> Unit>

data class NullableValue<T> : GroupWithNullableEntries<T>

NullableValue(expected: T)
val expected: T
fun toList(): <ERROR CLASS>

class NullableValues<T> : GroupWithNullableEntries<T>

NullableValues(expected: T, vararg otherExpected: T)
vararg val otherExpected: Array<out T>
fun toList(): <ERROR CLASS>

data class Value<T : Any> : GroupWithoutNullableEntries<T>

Value(expected: T)
val expected: T
fun toList(): <ERROR CLASS>

class Values<T : Any> : GroupWithoutNullableEntries<T>

Values(expected: T, vararg otherExpected: T)
vararg val otherExpected: Array<out T>
fun toList(): <ERROR CLASS>

fun <E : Any, T : Iterable<E>> Assert<T>.all(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.allOfNullable(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
val <T : Any> AssertionPlant<T>.and: AssertionPlant<T>
infix fun <T : Any> AssertionPlant<T>.and(assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.any(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.anyOfNullable(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E> Assert<Array<E>>.asIterable(): AssertionPlant<Iterable<E>>
fun Assert<ByteArray>.asIterable(): AssertionPlant<Iterable<Byte>>
fun Assert<CharArray>.asIterable(): AssertionPlant<Iterable<Char>>
fun Assert<ShortArray>.asIterable(): AssertionPlant<Iterable<Short>>
fun Assert<IntArray>.asIterable(): AssertionPlant<Iterable<Int>>
fun Assert<LongArray>.asIterable(): AssertionPlant<Iterable<Long>>
fun Assert<FloatArray>.asIterable(): AssertionPlant<Iterable<Float>>
fun Assert<DoubleArray>.asIterable(): AssertionPlant<Iterable<Double>>
fun Assert<BooleanArray>.asIterable(): AssertionPlant<Iterable<Boolean>>
fun <E, T> Assert<T>.asIterable(): <ERROR CLASS>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atLeast(times: Int): AtLeastCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atLeast(times: Int): AtLeastCheckerOption<E, T, S>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atMost(times: Int): AtMostCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atMost(times: Int): AtMostCheckerOption<E, T, S>
fun <T : CharSequence, S : SearchBehaviour> AtLeastCheckerOption<T, S>.butAtMost(times: Int): ButAtMostCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> AtLeastCheckerOption<E, T, S>.butAtMost(times: Int): ButAtMostCheckerOption<E, T, S>
val <T : CharSequence> Assert<T>.contains: Builder<T, NoOpSearchBehaviour>
fun <T : CharSequence> Assert<T>.contains(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.contains(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.contains(assertionCreator: Assert<E>.() -> Unit): <ERROR CLASS>
fun <E : Any, T : Iterable<E>> Assert<T>.contains(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
val <T : CharSequence> Assert<T>.containsNot: NotCheckerOption<T, NotSearchBehaviour>
fun <T : CharSequence> Assert<T>.containsNot(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.containsNot(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.containsNullableEntries(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.containsNullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsNullableValue(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsNullableValues(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.containsRegex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.containsStrictlyNullableEntries(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.containsStrictlyNullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsStrictlyNullableValue(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsStrictlyNullableValues(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.endsNotWith(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.endsWith(expected: CharSequence): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.entries(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.entries(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.entries(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.exactly(times: Int): ExactlyCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.exactly(times: Int): ExactlyCheckerOption<E, T, S>
val <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.grouped: <ERROR CLASS>
fun <T : Collection<*>> Assert<T>.hasSize(size: Int): AssertionPlant<T>
val <T : CharSequence> Builder<T, NoOpSearchBehaviour>.ignoringCase: Builder<T, IgnoringCaseSearchBehaviour>
val <T : CharSequence> NotCheckerOption<T, NotSearchBehaviour>.ignoringCase: NotCheckerOption<T, IgnoringCaseSearchBehaviour>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAnyOrder(firstGroup: GroupWithoutNullableEntries<E>, secondGroup: GroupWithoutNullableEntries<E>, vararg otherExpectedGroups: GroupWithoutNullableEntries<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAnyOrder(firstGroup: GroupWithNullableEntries<E>, secondGroup: GroupWithNullableEntries<E>, vararg otherExpectedGroups: GroupWithNullableEntries<E>): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAnyOrder(firstGroup: GroupWithoutNullableEntries<Assert<E>.() -> Unit>, secondGroup: GroupWithoutNullableEntries<Assert<E>.() -> Unit>, vararg otherExpectedGroups: GroupWithoutNullableEntries<Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAnyOrder(firstGroup: GroupWithNullableEntries<Assert<E>.() -> Unit>, secondGroup: GroupWithNullableEntries<Assert<E>.() -> Unit>, vararg otherExpectedGroups: GroupWithNullableEntries<Assert<E>.() -> Unit>): AssertionPlant<T>
val <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inAnyOrder: <ERROR CLASS>
val <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inOrder: <ERROR CLASS>
inline fun <reified TSub : Any> Assert<Any>.isA(noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
fun <T : CharSequence> Assert<T>.isEmpty(): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isEqualIncludingScale(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isGreaterOrEquals(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isGreaterThan(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isLessOrEquals(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isLessThan(expected: T): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.isNotEmpty(): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isNotEqualIncludingScale(expected: T): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isNotNumericallyEqualTo(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.isNotSameAs(expected: T): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isNumericallyEqualTo(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.isSameAs(expected: T): AssertionPlant<T>
fun <T : Throwable> Assert<T>.message(assertionCreator: Assert<String>.() -> Unit): Unit
fun <T : Throwable> Assert<T>.messageContains(expected: Any, vararg otherExpected: Any): Unit
fun <E : Any, T : Iterable<E>> Assert<T>.none(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.noneOfNullable(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<E, T, S>
fun <T : Any> Assert<T>.notToBe(expected: T): AssertionPlant<T>
inline fun <reified T : Any> AssertionPlantNullable<T?>.notToBeNull(noinline assertionCreator: Assert<T>.() -> Unit): Unit
inline fun <reified T : Any> AssertionPlantNullable<T?>.notToBeNullBut(expected: T): Unit
fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.nullableEntries(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.nullableEntries(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.nullableEntries(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.nullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.nullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.nullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableValues(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableValues(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.nullableValues(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
val <E, T : Iterable<E>> Builder<E, T, InAnyOrderSearchBehaviour>.only: <ERROR CLASS>
val <E, T : Iterable<E>> Builder<E, T, InOrderSearchBehaviour>.only: <ERROR CLASS>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction0<R>): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction0<R>): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction1<T, R>): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction1<T, R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction2<T, T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction2<T, T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : CharSequence> Assert<T>.startsNotWith(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.startsWith(expected: CharSequence): AssertionPlant<T>
fun <T : Any> Assert<T>.toBe(expected: T): AssertionPlant<T>
fun <T> AssertionPlantNullable<T>.toBe(null: Nothing?): Unit
fun Assert<Float>.toBeWithErrorTolerance(expected: Float, tolerance: Float): AssertionPlant<Float>
fun Assert<Double>.toBeWithErrorTolerance(expected: Double, tolerance: Double): AssertionPlant<Double>
fun Assert<BigDecimal>.toBeWithErrorTolerance(expected: BigDecimal, tolerance: BigDecimal): AssertionPlant<BigDecimal>
inline fun <reified TExpected : Throwable> Builder.toThrow(noinline assertionCreator: Assert<TExpected>.() -> Unit): Unit
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.value(expected: Any): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.value(expected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.values(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.values(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
val <E, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedSearchBehaviour>.within: <ERROR CLASS>

package ch.tutteli.atrium.api.cc.en_GB.creating.charsequence.contains.builders

interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>

package ch.tutteli.atrium.api.cc.en_GB.creating.iterable.contains.builders

interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>

package ch.tutteli.atrium.api.cc.en_UK

object CharSequenceContainsSearchersKt

fun <T : CharSequence> defaultTranslationOf(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> value(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> values(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>

val <T : Any> AssertionPlant<T>.and: AssertionPlant<T>
infix fun <T : Any> AssertionPlant<T>.and(assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atLeast(times: Int): AtLeastCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> atLeast(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtLeastCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atLeast(times: Int): AtLeastCheckerOption<E, T, S>
fun <E, T : Iterable<E>> atLeast(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtLeastCheckerBuilder<E, T>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atMost(times: Int): AtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> atMost(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atMost(times: Int): AtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> atMost(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtMostCheckerBuilder<E, T>
fun <T : CharSequence, S : SearchBehaviour> AtLeastCheckerOption<T, S>.butAtMost(times: Int): ButAtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> butAtMost(checkerBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, times: Int): CharSequenceContainsButAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> AtLeastCheckerOption<E, T, S>.butAtMost(times: Int): ButAtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> butAtMost(checkerBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, times: Int): IterableContainsButAtMostCheckerBuilder<E, T>
val <T : CharSequence> Assert<T>.contains: Builder<T, NoOpSearchBehaviour>
fun <T : CharSequence> Assert<T>.contains(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.contains(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.contains(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.containsDefaultTranslationOf(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
val <T : CharSequence> Assert<T>.containsNot: NotCheckerOption<T, NotSearchBehaviour>
fun <T : CharSequence> Assert<T>.containsNot(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsNot(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.containsNotDefaultTranslationOf(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsNullable(plant: Assert<T>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.containsRegex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsStrictly(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsStrictlyNulllable(plant: Assert<T>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.defaultTranslationOf(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.defaultTranslationOf(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.endsNotWith(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.endsWith(expected: CharSequence): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.entries(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entries(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.entries(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entries(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.entries(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entries(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.exactly(times: Int): ExactlyCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> exactly(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsExactlyCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.exactly(times: Int): ExactlyCheckerOption<E, T, S>
fun <E, T : Iterable<E>> exactly(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsExactlyCheckerBuilder<E, T>
fun <T : CharSequence> getContains(plant: Assert<T>): CharSequenceContainsBuilder<T, NoOpSearchBehaviour>
fun <T : CharSequence> getContainsNot(plant: Assert<T>): CharSequenceContainsNotCheckerBuilder<T, NotSearchBehaviour>
fun <T : CharSequence> getIgnoringCase(builder: CharSequenceContainsBuilder<T, NoOpSearchBehaviour>): CharSequenceContainsBuilder<T, IgnoringCaseSearchBehaviour>
fun <T : CharSequence> getIgnoringCase(builder: CharSequenceContainsNotCheckerBuilder<T, NotSearchBehaviour>): CharSequenceContainsNotCheckerBuilder<T, IgnoringCaseSearchBehaviour>
fun <E, T : Iterable<E>> getInAnyOrder(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>): IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>
fun <E, T : Iterable<E>> getInOrder(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>): IterableContainsBuilder<E, T, InOrderSearchBehaviour>
fun <T : Collection<*>> Assert<T>.hasSize(size: Int): AssertionPlant<T>
val <T : CharSequence> Builder<T, NoOpSearchBehaviour>.ignoringCase: Builder<T, IgnoringCaseSearchBehaviour>
val <T : CharSequence> NotCheckerOption<T, NotSearchBehaviour>.ignoringCase: NotCheckerOption<T, IgnoringCaseSearchBehaviour>
val <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inAnyOrder: <ERROR CLASS>
fun <E, T : Iterable<E>> inAnyOrderOnly(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>): IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>
val <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inOrder: <ERROR CLASS>
fun <E, T : Iterable<E>> inOrderOnly(builder: IterableContainsBuilder<E, T, InOrderSearchBehaviour>): IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>
inline fun <reified TSub : Any> Assert<Any>.isA(noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
fun <T : CharSequence> Assert<T>.isEmpty(): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isEqualIncludingScale(expected: T): AssertionPlant<T>
fun Assert<Boolean>.isFalse(): AssertionPlant<Boolean>
fun <T : Comparable<T>> Assert<T>.isGreaterOrEquals(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isGreaterThan(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isLessOrEquals(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isLessThan(expected: T): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.isNotEmpty(): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isNotEqualIncludingScale(expected: T): AssertionPlant<T>
inline fun <reified T : Any> AssertionPlantNullable<T?>.isNotNull(noinline assertionCreator: Assert<T>.() -> Unit): Unit
fun <T : BigDecimal> Assert<T>.isNotNumericallyEqualTo(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.isNotSame(expected: T): AssertionPlant<T>
fun <T> AssertionPlantNullable<T>.isNull(): Unit
fun <T : BigDecimal> Assert<T>.isNumericallyEqualTo(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.isSame(expected: T): AssertionPlant<T>
fun Assert<Boolean>.isTrue(): AssertionPlant<Boolean>
fun <T : Throwable> Assert<T>.message(assertionCreator: Assert<String>.() -> Unit): Unit
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> notOrAtMost(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsNotOrAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> notOrAtMost(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsNotOrAtMostCheckerBuilder<E, T>
fun <T : Any> Assert<T>.notToBe(expected: T): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntries(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntries(checkerBuilder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntries(checkerBuilder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(checkerBuilder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(checkerBuilder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableValue(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableValue(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.nullableValue(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableValues(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableValues(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.nullableValues(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.objects(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objects(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.objects(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objects(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.objects(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objects(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
val <E, T : Iterable<E>> Builder<E, T, InAnyOrderSearchBehaviour>.only: <ERROR CLASS>
val <E, T : Iterable<E>> Builder<E, T, InOrderSearchBehaviour>.only: <ERROR CLASS>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>, assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : Any, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction0<TReturnValue>): AssertionPlant<TReturnValue>
fun <T : Any, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction0<TReturnValue>, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction1<T1, TReturnValue>, arg1: T1): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction1<T1, TReturnValue>, arg1: T1, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : CharSequence> Assert<T>.startsNotWith(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.startsWith(expected: CharSequence): AssertionPlant<T>
fun <T : Any> Assert<T>.toBe(expected: T): AssertionPlant<T>
fun Assert<Float>.toBeWithErrorTolerance(expected: Float, tolerance: Float): AssertionPlant<Float>
fun Assert<Double>.toBeWithErrorTolerance(expected: Double, tolerance: Double): AssertionPlant<Double>
fun Assert<BigDecimal>.toBeWithErrorTolerance(expected: BigDecimal, tolerance: BigDecimal): AssertionPlant<BigDecimal>
inline fun <reified TExpected : Throwable> Builder.toThrow(): Unit
inline fun <reified TExpected : Throwable> Builder.toThrow(noinline assertionCreator: Assert<TExpected>.() -> Unit): Unit
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.value(expected: Any): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.value(expected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> value(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> value(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> value(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.values(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.values(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> values(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> values(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> values(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>

package ch.tutteli.atrium.api.cc.en_UK.assertions.charsequence.contains.builders

open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtLeastCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtMostCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, containsBuilder: Builder<T, S>)

open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsExactlyCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotCheckerBuilder(containsBuilder: Builder<T, S>)

open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

package ch.tutteli.atrium.api.cc.en_UK.assertions.iterable.contains.builders

open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtLeastCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtMostCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsExactlyCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotCheckerBuilder(containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

package ch.tutteli.atrium.api.cc.en_UK.creating.charsequence.contains.builders

interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
open class AtLeastCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionBase<T, S>, AtLeastCheckerOption<T, S>

AtLeastCheckerOptionImpl(times: Int, containsBuilder: Builder<T, S>)

interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class AtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionBase<T, S>, AtMostCheckerOption<T, S>

AtMostCheckerOptionImpl(times: Int, containsBuilder: Builder<T, S>)

interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class ButAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionBase<T, S>, ButAtMostCheckerOption<T, S>

ButAtMostCheckerOptionImpl(times: Int, atLeastBuilder: AtLeastCheckerOption<T, S>, containsBuilder: Builder<T, S>)

interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class ExactlyCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionBase<T, S>, ExactlyCheckerOption<T, S>

ExactlyCheckerOptionImpl(times: Int, containsBuilder: Builder<T, S>)

interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class NotCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionBase<T, S>, NotCheckerOption<T, S>

NotCheckerOptionImpl(containsBuilder: Builder<T, S>)

interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class NotOrAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionBase<T, S>, NotOrAtMostCheckerOption<T, S>

NotOrAtMostCheckerOptionImpl(times: Int, containsBuilder: Builder<T, S>)

package ch.tutteli.atrium.api.cc.en_UK.creating.iterable.contains.builders

interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class AtLeastCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtLeastCheckerOptionBase<E, T, S>, AtLeastCheckerOption<E, T, S>

AtLeastCheckerOptionImpl(times: Int, containsBuilder: Builder<E, T, S>)

interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class AtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtMostCheckerOptionBase<E, T, S>, AtMostCheckerOption<E, T, S>

AtMostCheckerOptionImpl(times: Int, containsBuilder: Builder<E, T, S>)

interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class ButAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ButAtMostCheckerOptionBase<E, T, S>, ButAtMostCheckerOption<E, T, S>

ButAtMostCheckerOptionImpl(times: Int, atLeastBuilder: AtLeastCheckerOption<E, T, S>, containsBuilder: Builder<E, T, S>)

interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class ExactlyCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ExactlyCheckerOptionBase<E, T, S>, ExactlyCheckerOption<E, T, S>

ExactlyCheckerOptionImpl(times: Int, containsBuilder: Builder<E, T, S>)

interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
open class NotCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotCheckerOptionBase<E, T, S>, NotCheckerOption<E, T, S>

NotCheckerOptionImpl(containsBuilder: Builder<E, T, S>)

interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class NotOrAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotOrAtMostCheckerOptionBase<E, T, S>, NotOrAtMostCheckerOption<E, T, S>

NotOrAtMostCheckerOptionImpl(times: Int, containsBuilder: Builder<E, T, S>)

package ch.tutteli.atrium.api.cc.infix.en_GB

class Entries<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>

Entries(assertionCreator: Assert<T>.() -> Unit, vararg otherAssertionCreators: Assert<T>.() -> Unit)
val assertionCreator: Assert<T>.() -> Unit
vararg val otherAssertionCreators: Array<Assert<T>.() -> Unit>
fun toList(): List<Assert<T>.() -> Unit>

class Entry<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>

Entry(assertionCreator: Assert<T>.() -> Unit)
val assertionCreator: Assert<T>.() -> Unit
fun toList(): List<Assert<T>.() -> Unit>

class NullableEntries<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>

NullableEntries(assertionCreatorOrNull: Assert<T>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<T>.() -> Unit)
val assertionCreatorOrNull: Assert<T>.() -> Unit
vararg val otherAssertionCreatorsOrNulls: Array<Assert<T>.() -> Unit>
fun toList(): List<Assert<T>.() -> Unit>

class NullableEntry<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>

NullableEntry(assertionCreator: Assert<T>.() -> Unit)
val assertionCreator: Assert<T>.() -> Unit
fun toList(): List<Assert<T>.() -> Unit>

class NullableValue<out T> : GroupWithNullableEntries<T>

NullableValue(expected: T)
val expected: T
fun toList(): List<T>

class NullableValues<out T> : GroupWithNullableEntries<T>

NullableValues(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>
fun toList(): List<T>

class Order<T, G : Group<T>>

Order(firstGroup: G, secondGroup: G, vararg otherExpectedGroups: G)
val firstGroup: G
vararg val otherExpectedGroups: Array<out G>
val secondGroup: G

class RegexPatterns

RegexPatterns(pattern: String, vararg otherPatterns: String)
vararg val otherPatterns: Array<out String>
val pattern: String
fun toList(): List<String>

class Value<out T : Any> : GroupWithoutNullableEntries<T>

Value(expected: T)
val expected: T
fun toList(): List<T>

class Values<out T : Any> : GroupWithoutNullableEntries<T>

Values(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>
fun toList(): List<T>

infix fun <E : Any, T : Iterable<E>> Assert<T>.all(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.all(nullableEntry: NullableEntry<E>): AssertionPlant<T>
infix fun <T : Any> AssertionPlant<T>.and(assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderSearchBehaviour>.and(only: only): <ERROR CLASS>
infix fun <E : Any, T : Iterable<E>> Assert<T>.any(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.any(nullableEntry: NullableEntry<E>): AssertionPlant<T>
fun <E> Assert<Array<E>>.asIterable(): AssertionPlant<Iterable<E>>
fun Assert<ByteArray>.asIterable(): AssertionPlant<Iterable<Byte>>
fun Assert<CharArray>.asIterable(): AssertionPlant<Iterable<Char>>
fun Assert<ShortArray>.asIterable(): AssertionPlant<Iterable<Short>>
fun Assert<IntArray>.asIterable(): AssertionPlant<Iterable<Int>>
fun Assert<LongArray>.asIterable(): AssertionPlant<Iterable<Long>>
fun Assert<FloatArray>.asIterable(): AssertionPlant<Iterable<Float>>
fun Assert<DoubleArray>.asIterable(): AssertionPlant<Iterable<Double>>
fun Assert<BooleanArray>.asIterable(): AssertionPlant<Iterable<Boolean>>
fun <E, T> Assert<T>.asIterable(): <ERROR CLASS>
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atLeast(times: Int): AtLeastCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atLeast(times: Int): AtLeastCheckerOption<E, T, S>
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atMost(times: Int): AtMostCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atMost(times: Int): AtMostCheckerOption<E, T, S>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderSearchBehaviour>.but(only: only): <ERROR CLASS>
infix fun <T : CharSequence, S : SearchBehaviour> AtLeastCheckerOption<T, S>.butAtMost(times: Int): ButAtMostCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> AtLeastCheckerOption<E, T, S>.butAtMost(times: Int): ButAtMostCheckerOption<E, T, S>
infix fun <T : CharSequence> Assert<T>.contains(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.contains(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.contains(patterns: RegexPatterns): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.contains(expected: E): <ERROR CLASS>
infix fun <E, T : Iterable<E>> Assert<T>.contains(expected: NullableValue<E>): <ERROR CLASS>
infix fun <E : Any, T : Iterable<E>> Assert<T>.contains(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.contains(nullableValues: NullableValues<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.contains(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.contains(nullableEntry: NullableEntry<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.contains(entries: Entries<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.contains(nullableEntries: NullableEntries<E>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsNot(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsNot(values: Values<Any>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsNot(expected: E): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsNot(values: Values<E>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsRegex(pattern: String): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsStrictly(expected: NullableValue<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsStrictly(nullableValues: NullableValues<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.containsStrictly(nullableEntry: NullableEntry<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(entries: Entries<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.containsStrictly(nullableEntries: NullableEntries<E>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.endsNotWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.endsWith(expected: CharSequence): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.exactly(times: Int): ExactlyCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.exactly(times: Int): ExactlyCheckerOption<E, T, S>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.grouped(entries: entries): <ERROR CLASS>
infix fun <T : Collection<*>> Assert<T>.hasSize(size: Int): AssertionPlant<T>
infix fun <T : CharSequence> Builder<T, NoOpSearchBehaviour>.ignoring(case: case): Builder<T, IgnoringCaseSearchBehaviour>
infix fun <T : CharSequence> NotCheckerOption<T, NotSearchBehaviour>.ignoring(case: case): NotCheckerOption<T, IgnoringCaseSearchBehaviour>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAny(order: Order<E, GroupWithoutNullableEntries<E>>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAny(order: Order<E, GroupWithNullableEntries<E>>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAny(order: Order<Assert<E>.() -> Unit, GroupWithoutNullableEntries<Assert<E>.() -> Unit>>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAny(order: Order<Assert<E>.() -> Unit, GroupWithNullableEntries<Assert<E>.() -> Unit>>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inAny(order: order): <ERROR CLASS>
infix fun <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inGiven(order: order): <ERROR CLASS>
inline infix fun <reified TSub : Any> Assert<Any>.isA(noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
infix fun <T : BigDecimal> Assert<T>.isEqualIncludingScale(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isGreaterOrEquals(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isGreaterThan(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isLessOrEquals(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isLessThan(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNotEqualIncludingScale(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNotNumericallyEqualTo(expected: T): AssertionPlant<T>
infix fun <T : Any> Assert<T>.isNotSameAs(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNumericallyEqualTo(expected: T): AssertionPlant<T>
infix fun <T : Any> Assert<T>.isSameAs(expected: T): AssertionPlant<T>
infix fun <T : Throwable> Assert<T>.message(assertionCreator: Assert<String>.() -> Unit): Unit
infix fun <T : Throwable> Assert<T>.messageContains(expected: Any): Unit
infix fun <T : Throwable> Assert<T>.messageContains(values: Values<Any>): Unit
infix fun <E : Any, T : Iterable<E>> Assert<T>.none(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.none(nullableEntry: NullableEntry<E>): AssertionPlant<T>
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<E, T, S>
infix fun <T : CharSequence> Assert<T>.notTo(contain: contain): NotCheckerOption<T, NotSearchBehaviour>
infix fun <T : Any> Assert<T>.notToBe(expected: T): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.notToBe(onlyEmptyAllowed: Empty): AssertionPlant<T>
inline infix fun <reified T : Any> AssertionPlantNullable<T?>.notToBeNull(noinline assertionCreator: Assert<T>.() -> Unit): Unit
inline infix fun <reified T : Any> AssertionPlantNullable<T?>.notToBeNullBut(expected: T): Unit
infix fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.nullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.nullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.nullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: String): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.regex(pattern: String): AssertionPlant<T>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction0<R>): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction0<R>): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction1<T, R>): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction1<T, R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction2<T, T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction2<T, T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
infix fun <T : CharSequence> Assert<T>.startsNotWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.startsWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.the(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.the(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.the(patterns: RegexPatterns): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.the(patterns: RegexPatterns): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(nullableValues: NullableValues<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(entries: Entries<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.the(nullableEntries: NullableEntries<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(values: NullableValues<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(entries: Entries<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.the(nullableEntries: NullableEntries<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.the(nullableValues: NullableValues<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.the(entries: Entries<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.the(nullableEntries: NullableEntries<E>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.to(contain: contain): Builder<T, NoOpSearchBehaviour>
infix fun <T : Any> Assert<T>.toBe(expected: T): AssertionPlant<T>
infix fun <T> AssertionPlantNullable<T>.toBe(null: Nothing?): Unit
infix fun <T : CharSequence> Assert<T>.toBe(Empty: Empty): AssertionPlant<T>
inline infix fun <reified TExpected : Throwable> Builder.toThrow(noinline assertionCreator: Assert<TExpected>.() -> Unit): Unit
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.value(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.value(expected: Any): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.value(expected: E): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedSearchBehaviour>.within(group: group): <ERROR CLASS>

package ch.tutteli.atrium.api.cc.infix.en_GB.creating.charsequence.contains.builders

interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>

package ch.tutteli.atrium.api.cc.infix.en_GB.creating.iterable.contains.builders

interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>

package ch.tutteli.atrium.api.cc.infix.en_GB.keywords

object Empty
object case
object contain
object entries
object group
object only
object order

package ch.tutteli.atrium.api.cc.infix.en_UK

object CharSequenceContainsSearchersKt

fun <T : CharSequence> defaultTranslationOf(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, translatable: Translatable): AssertionPlant<T>
fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, translatable: Translatable): AssertionPlant<T>
fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, patterns: RegexPatterns): AssertionPlant<T>
fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, values: Values<Any>): AssertionPlant<T>
fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, translatables: DefaultTranslationsOf): AssertionPlant<T>
fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, patterns: RegexPatterns): AssertionPlant<T>
fun <T : CharSequence> value(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, values: Values<Any>): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, translatables: DefaultTranslationsOf): AssertionPlant<T>

class DefaultTranslationsOf

DefaultTranslationsOf(expected: Translatable, vararg otherExpected: Translatable)
val expected: Translatable
vararg val otherExpected: Array<out Translatable>
fun toList(): List<Translatable>

object Empty
class Entries<in T : Any, out A : (Assert<T>) -> Unit>

Entries(assertionCreator: A, vararg otherAssertionCreators: A)
val assertionCreator: A
vararg val otherAssertionCreators: Array<out A>
fun toList(): List<A>

class Objects<out T>

Objects(values: Values<T>)
Objects(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>

class RegexPatterns

RegexPatterns(pattern: String, vararg otherPatterns: String)
vararg val otherPatterns: Array<out String>
val pattern: String
fun toList(): List<String>

class Values<out T>

Values(objects: Objects<T>)
Values(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>
fun toList(): List<T>

infix fun <T : Any> AssertionPlant<T>.and(assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atLeast(times: Int): AtLeastCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> atLeast(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtLeastCheckerBuilder<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atLeast(times: Int): AtLeastCheckerOption<E, T, S>
fun <E, T : Iterable<E>> atLeast(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtLeastCheckerBuilder<E, T>
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atMost(times: Int): AtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> atMost(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtMostCheckerBuilder<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atMost(times: Int): AtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> atMost(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtMostCheckerBuilder<E, T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderSearchBehaviour>.but(only: only): <ERROR CLASS>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderSearchBehaviour>.but(only: only): <ERROR CLASS>
infix fun <T : CharSequence, S : SearchBehaviour> AtLeastCheckerOption<T, S>.butAtMost(times: Int): ButAtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> butAtMost(checkerBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, times: Int): CharSequenceContainsButAtMostCheckerBuilder<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> AtLeastCheckerOption<E, T, S>.butAtMost(times: Int): ButAtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> butAtMost(checkerBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, times: Int): IterableContainsButAtMostCheckerBuilder<E, T>
object case
object contain
infix fun <T : CharSequence> Assert<T>.contains(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.contains(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.contains(defaultTranslationOf: DefaultTranslationsOf): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.contains(patterns: RegexPatterns): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.contains(expected: E): <ERROR CLASS>
infix fun <E, T : Iterable<E>> Assert<T>.contains(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.contains(objects: Objects<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.contains(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.contains(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsDefaultTranslationOf(translatable: Translatable): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsNot(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsNot(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsNot(defaultTranslationsOf: DefaultTranslationsOf): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsNot(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsNot(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsNot(objects: Objects<E>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsNullable(plant: Assert<T>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsNullable(plant: Assert<T>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsRegex(pattern: String): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsStrictly(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsStrictly(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsStrictly(objects: Objects<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsStrictlyNullable(plant: Assert<T>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsStrictlyNullable(plant: Assert<T>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.defaultTranslationOf(translatable: Translatable): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.defaultTranslationOf(translatable: Translatable): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.endsNotWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.endsWith(expected: CharSequence): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.exactly(times: Int): ExactlyCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> exactly(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsExactlyCheckerBuilder<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.exactly(times: Int): ExactlyCheckerOption<E, T, S>
fun <E, T : Iterable<E>> exactly(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsExactlyCheckerBuilder<E, T>
infix fun <T : Collection<*>> Assert<T>.hasSize(size: Int): AssertionPlant<T>
infix fun <T : CharSequence> Builder<T, NoOpSearchBehaviour>.ignoring(case: case): Builder<T, IgnoringCaseSearchBehaviour>
fun <T : CharSequence> ignoring(builder: CharSequenceContainsBuilder<T, NoOpSearchBehaviour>, case: case): CharSequenceContainsBuilder<T, IgnoringCaseSearchBehaviour>
infix fun <T : CharSequence> NotCheckerOption<T, NotSearchBehaviour>.ignoring(case: case): NotCheckerOption<T, IgnoringCaseSearchBehaviour>
fun <T : CharSequence> CharSequenceContainsNotCheckerBuilder<T, NotSearchBehaviour>.ignoring(case: case): CharSequenceContainsNotCheckerBuilder<T, IgnoringCaseSearchBehaviour>
infix fun <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inAny(order: order): <ERROR CLASS>
fun <E, T : Iterable<E>> inAny(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>, order: order): IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>
fun <E, T : Iterable<E>> inAnyOrderOnly(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, only: only): IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>
infix fun <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inGiven(order: order): <ERROR CLASS>
fun <E, T : Iterable<E>> inGiven(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>, order: order): IterableContainsBuilder<E, T, InOrderSearchBehaviour>
fun <E, T : Iterable<E>> inOrderOnly(builder: IterableContainsBuilder<E, T, InOrderSearchBehaviour>, only: only): IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>
inline infix fun <reified TSub : Any> Assert<Any>.isA(noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
infix fun <T : BigDecimal> Assert<T>.isEqualIncludingScale(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isGreaterOrEquals(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isGreaterThan(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isLessOrEquals(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isLessThan(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNotEqualIncludingScale(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNotNumericallyEqualTo(expected: T): AssertionPlant<T>
infix fun <T : Any> Assert<T>.isNotSame(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNumericallyEqualTo(expected: T): AssertionPlant<T>
infix fun <T : Any> Assert<T>.isSame(expected: T): AssertionPlant<T>
infix fun <T : Throwable> Assert<T>.message(assertionCreator: Assert<String>.() -> Unit): Unit
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> notOrAtMost(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsNotOrAtMostCheckerBuilder<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> notOrAtMost(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsNotOrAtMostCheckerBuilder<E, T>
infix fun <T : CharSequence> Assert<T>.notTo(contain: contain): NotCheckerOption<T, NotSearchBehaviour>
infix fun <T : Any> Assert<T>.notToBe(expected: T): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.notToBe(onlyEmptyAllowed: Empty): AssertionPlant<T>
inline infix fun <reified T : Any> AssertionPlantNullable<T?>.notToBeNull(noinline assertionCreator: Assert<T>.() -> Unit): Unit
fun <E : Any, T : Iterable<E?>> nullableEntries(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntries(builder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntries(builder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(builder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(builder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
object only
object order
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>, assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: String): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.regex(pattern: String): AssertionPlant<T>
fun <T : Any, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction0<TReturnValue>): AssertionPlant<TReturnValue>
fun <T : Any, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction0<TReturnValue>, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction1<T1, TReturnValue>, arg1: T1): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction1<T1, TReturnValue>, arg1: T1, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
infix fun <T : CharSequence> Assert<T>.startsNotWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.startsWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.the(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.the(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.the(translatables: DefaultTranslationsOf): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.the(translatables: DefaultTranslationsOf): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.the(patterns: RegexPatterns): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.the(patterns: RegexPatterns): AssertionPlant<T>
infix fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(objects: Objects<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, objects: Objects<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> the(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(objects: Objects<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, objects: Objects<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.the(objects: Objects<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, objects: Objects<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.the(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.to(contain: contain): Builder<T, NoOpSearchBehaviour>
infix fun <T : Any> Assert<T>.toBe(expected: T): AssertionPlant<T>
infix fun <T> AssertionPlantNullable<T>.toBe(null: Nothing?): Unit
infix fun <T : CharSequence> Assert<T>.toBe(Empty: Empty): AssertionPlant<T>
inline fun <reified TExpected : Throwable> Builder.toThrow(): Unit
inline infix fun <reified TExpected : Throwable> Builder.toThrow(noinline assertionCreator: Assert<TExpected>.() -> Unit): Unit
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.value(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.value(expected: Any): AssertionPlant<T>
infix fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> value(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> value(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>

package ch.tutteli.atrium.api.cc.infix.en_UK.assertions.charsequence.contains.builders

open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtLeastCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtMostCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, containsBuilder: Builder<T, S>)

open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsExactlyCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotCheckerBuilder(containsBuilder: Builder<T, S>)

open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: Builder<T, S>)

fun nameContainsNotValuesFun(): String

package ch.tutteli.atrium.api.cc.infix.en_UK.assertions.iterable.contains.builders

open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtLeastCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtMostCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsExactlyCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotCheckerBuilder(containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: Builder<E, T, InAnyOrderSearchBehaviour>)

package ch.tutteli.atrium.api.cc.infix.en_UK.creating.charsequence.contains.builders

interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
open class AtLeastCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionBase<T, S>, AtLeastCheckerOption<T, S>

AtLeastCheckerOptionImpl(times: Int, containsBuilder: Builder<T, S>)

interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class AtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionBase<T, S>, AtMostCheckerOption<T, S>

AtMostCheckerOptionImpl(times: Int, containsBuilder: Builder<T, S>)

interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class ButAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionBase<T, S>, ButAtMostCheckerOption<T, S>

ButAtMostCheckerOptionImpl(times: Int, atLeastBuilder: AtLeastCheckerOption<T, S>, containsBuilder: Builder<T, S>)

interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class ExactlyCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionBase<T, S>, ExactlyCheckerOption<T, S>

ExactlyCheckerOptionImpl(times: Int, containsBuilder: Builder<T, S>)

interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class NotCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionBase<T, S>, NotCheckerOption<T, S>

NotCheckerOptionImpl(containsBuilder: Builder<T, S>)

interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class NotOrAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionBase<T, S>, NotOrAtMostCheckerOption<T, S>

NotOrAtMostCheckerOptionImpl(times: Int, containsBuilder: Builder<T, S>)

package ch.tutteli.atrium.api.cc.infix.en_UK.creating.iterable.contains.builders

interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class AtLeastCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtLeastCheckerOptionBase<E, T, S>, AtLeastCheckerOption<E, T, S>

AtLeastCheckerOptionImpl(times: Int, containsBuilder: Builder<E, T, S>)

interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class AtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtMostCheckerOptionBase<E, T, S>, AtMostCheckerOption<E, T, S>

AtMostCheckerOptionImpl(times: Int, containsBuilder: Builder<E, T, S>)

interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class ButAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ButAtMostCheckerOptionBase<E, T, S>, ButAtMostCheckerOption<E, T, S>

ButAtMostCheckerOptionImpl(times: Int, atLeastBuilder: AtLeastCheckerOption<E, T, S>, containsBuilder: Builder<E, T, S>)

interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class ExactlyCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ExactlyCheckerOptionBase<E, T, S>, ExactlyCheckerOption<E, T, S>

ExactlyCheckerOptionImpl(times: Int, containsBuilder: Builder<E, T, S>)

interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
open class NotCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotCheckerOptionBase<E, T, S>, NotCheckerOption<E, T, S>

NotCheckerOptionImpl(containsBuilder: Builder<E, T, S>)

interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class NotOrAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotOrAtMostCheckerOptionBase<E, T, S>, NotOrAtMostCheckerOption<E, T, S>

NotOrAtMostCheckerOptionImpl(times: Int, containsBuilder: Builder<E, T, S>)

package ch.tutteli.atrium.assertions

interface Assertion

abstract fun holds(): Boolean

interface AssertionGroup : Assertion

object Builder

class BasicAssertionGroupBuilder

BasicAssertionGroupBuilder(groupType: AssertionGroupType)
fun create(name: Translatable, subject: Any, assertion: Assertion): AssertionGroup
fun create(name: Translatable, subject: Any, assertions: List<Assertion>): AssertionGroup

class EmptyNameAndSubjectAssertionGroupBuilder

EmptyNameAndSubjectAssertionGroupBuilder(groupType: AssertionGroupType)
fun create(assertion: Assertion): AssertionGroup
fun create(assertions: List<Assertion>): AssertionGroup

class ExplanatoryAssertionGroupBuilder

ExplanatoryAssertionGroupBuilder(groupType: ExplanatoryAssertionGroupType)
fun create(assertion: Assertion): ExplanatoryAssertionGroup
fun create(assertions: List<Assertion>): ExplanatoryAssertionGroup

class ExplanatoryAssertionGroupOption

ExplanatoryAssertionGroupOption()
val withDefault: ExplanatoryAssertionGroupBuilder
fun withType(groupType: ExplanatoryAssertionGroupType): ExplanatoryAssertionGroupBuilder
val withWarning: ExplanatoryAssertionGroupBuilder

val explanatory: ExplanatoryAssertionGroupOption
val feature: BasicAssertionGroupBuilder
val invisible: EmptyNameAndSubjectAssertionGroupBuilder
val list: BasicAssertionGroupBuilder
val root: BasicAssertionGroupBuilder
val summary: BasicAssertionGroupBuilder
fun withType(groupType: AssertionGroupType): BasicAssertionGroupBuilder

abstract val assertions: List<Assertion>
abstract val description: Translatable
open fun holds(): <ERROR CLASS>
open val name: Translatable
abstract val representation: Any
open val subject: Any
abstract val type: AssertionGroupType

interface AssertionGroupType : BulletPointIdentifier
data class BasicAssertionGroup : AssertionGroup

BasicAssertionGroup(type: AssertionGroupType, description: Translatable, representation: Any, assertions: List<Assertion>)
val assertions: List<Assertion>
val description: Translatable
val representation: Any
val type: AssertionGroupType

class BasicDescriptiveAssertion : DescriptiveAssertion

BasicDescriptiveAssertion(description: Translatable, representation: Any, holds: Boolean)
BasicDescriptiveAssertion(description: Translatable, representation: Any, test: () -> Boolean)
val description: Translatable
fun holds(): Boolean
val representation: Any

class BasicExplanatoryAssertion : ExplanatoryAssertion

BasicExplanatoryAssertion(explanation: Any?)
val explanation: Any?

interface BulletPointIdentifier
object DefaultExplanatoryAssertionGroupType : ExplanatoryAssertionGroupType
object DefaultFeatureAssertionGroupType : FeatureAssertionGroupType
object DefaultIndentAssertionGroupType : IndentAssertionGroupType
object DefaultListAssertionGroupType : ListAssertionGroupType
object DefaultSummaryAssertionGroupType : SummaryAssertionGroupType
enum class DescriptionAnyAssertion : StringBasedTranslatable

IS_NOT_SAME
IS_SAME
NOT_TO_BE
TO_BE
val value: String

enum class DescriptionBasic : StringBasedTranslatable

IS
IS_NOT
val value: String

enum class DescriptionBigDecimalAssertion : StringBasedTranslatable

FAILURE_TO_BE_BUT_NUMERICALLY_EQUAL
IS_EQUAL_INCLUDING_SCALE
IS_NOT_EQUAL_INCLUDING_SCALE
IS_NOT_NUMERICALLY_EQUAL_TO
IS_NUMERICALLY_EQUAL_TO
val value: String

enum class DescriptionCharSequenceAssertion : StringBasedTranslatable

AT_LEAST
AT_MOST
CONTAINS
CONTAINS_NOT
EMPTY
ENDS_NOT_WITH
ENDS_WITH
EXACTLY
IGNORING_CASE
NUMBER_OF_OCCURRENCES
STARTS_NOT_WITH
STARTS_WITH
val value: String

enum class DescriptionCollectionAssertion : StringBasedTranslatable

EMPTY
HAS_SIZE
val value: String

enum class DescriptionComparableAssertion : StringBasedTranslatable

IS_GREATER_OR_EQUALS
IS_GREATER_THAN
IS_LESS_OR_EQUALS
IS_LESS_THAN
val value: String

enum class DescriptionFloatingPointAssertion : StringBasedTranslatable

FAILURE_DUE_TO_FLOATING_POINT_NUMBER
TO_BE_WITH_ERROR_TOLERANCE
TO_BE_WITH_ERROR_TOLERANCE_EXPLAINED
val value: String

enum class DescriptionIterableAssertion : StringBasedTranslatable

AN_ENTRY_WHICH
AN_ENTRY_WHICH_IS
AT_LEAST
AT_MOST
CANNOT_EVALUATE_SUBJECT_EMPTY_ITERABLE
CANNOT_EVALUATE_SUBJECT_ONLY_NULL
CONTAINS
CONTAINS_NOT
ENTRY_WITH_INDEX
EXACTLY
IN_ANY_ORDER
IN_ANY_ORDER_ONLY
IN_ORDER
IN_ORDER_ONLY
NUMBER_OF_OCCURRENCES
SIZE_EXCEEDED
WARNING_ADDITIONAL_ENTRIES
WARNING_MISMATCHES
WARNING_MISMATCHES_ADDITIONAL_ENTRIES
val value: String

enum class DescriptionThrowableAssertion : StringBasedTranslatable

IS_A
NO_EXCEPTION_OCCURRED
val value: String

enum class DescriptionTypeTransformationAssertion : StringBasedTranslatable

IS_A
WARNING_DOWN_CAST_FAILED
val value: String

interface DescriptiveAssertion : Assertion

abstract val description: Translatable
open val expected: Any
abstract val representation: Any

interface DoNotFilterAssertionGroupType : AssertionGroupType
open class EmptyNameAndRepresentationAssertionGroup : AssertionGroup

EmptyNameAndRepresentationAssertionGroup(type: AssertionGroupType, assertions: List<Assertion>)
open val assertions: List<Assertion>
open val description: Translatable
open val representation: Any
open val type: AssertionGroupType

interface ExplanatoryAssertion : Assertion

abstract val explanation: Any?
open fun holds(): Boolean

class ExplanatoryAssertionGroup : EmptyNameAndRepresentationAssertionGroup

fun holds(): Boolean

interface ExplanatoryAssertionGroupType : DoNotFilterAssertionGroupType
interface FeatureAssertionGroupType : AssertionGroupType
class IndentAssertionGroup : EmptyNameAndRepresentationAssertionGroup

IndentAssertionGroup(assertions: List<Assertion>)

interface IndentAssertionGroupType : AssertionGroupType
class InvisibleAssertionGroup : EmptyNameAndRepresentationAssertionGroup
object InvisibleAssertionGroupType : AssertionGroupType
interface ListAssertionGroupType : AssertionGroupType
class PrefixFailingSummaryAssertion : BulletPointIdentifier
class PrefixFeatureAssertionGroupHeader : BulletPointIdentifier
class PrefixSuccessfulSummaryAssertion : BulletPointIdentifier
object RootAssertionGroupType : AssertionGroupType
interface SummaryAssertionGroupType : DoNotFilterAssertionGroupType
object WarningAssertionGroupType : ExplanatoryAssertionGroupType
fun <T : CharSequence> _containsBuilder(plant: AssertionPlant<T>): <ERROR CLASS>
fun <T : CharSequence> _containsNotBuilder(plant: AssertionPlant<T>): <ERROR CLASS>
fun <T : Any, TSub : T> _downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
fun <T : CharSequence> _endsNotWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion
fun <T : CharSequence> _endsWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion
fun <T : Collection<*>> _hasSize(plant: AssertionPlant<T>, size: Int): Assertion
inline fun <reified TSub : Any> _isA(plant: AssertionPlant<Any>, noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
fun <T : CharSequence> _isEmpty(plant: AssertionPlant<T>): Assertion
fun <T : BigDecimal> _isEqualIncludingScale(plant: AssertionPlant<T>, expected: T, nameOfIsNumericallyEqualTo: String): Assertion
fun <T : Comparable<T>> _isGreaterOrEquals(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
fun <T : Comparable<T>> _isGreaterThan(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
fun <T : Comparable<T>> _isLessOrEquals(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
fun <T : Comparable<T>> _isLessThan(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
fun <T : CharSequence> _isNotEmpty(plant: AssertionPlant<T>): Assertion
fun <T : BigDecimal> _isNotEqualIncludingScale(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
inline fun <reified T : Any> _isNotNull(plant: AssertionPlantNullable<T?>, noinline assertionCreator: AssertionPlant<T>.() -> Unit): Unit
fun <T : BigDecimal> _isNotNumericallyEqualTo(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
fun <T : Any> _isNotSame(plant: AssertionPlant<T>, expected: T): Assertion
fun <T> _isNull(plant: AssertionPlantNullable<T>): Assertion
fun <T : BigDecimal> _isNumericallyEqualTo(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
fun <T : Any> _isSame(plant: AssertionPlant<T>, expected: T): Assertion
fun <T : Any, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: () -> TReturnValue): AssertionPlant<TReturnValue>
fun <T : Any, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: () -> TReturnValue, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1) -> TReturnValue, arg1: T1): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1) -> TReturnValue, arg1: T1, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2) -> TReturnValue, arg1: T1, arg2: T2): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2) -> TReturnValue, arg1: T1, arg2: T2, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3, T4) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3, T4) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3, T4, T5) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3, T4, T5) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any> _notToBe(plant: AssertionPlant<T>, expected: T): Assertion
fun <T : Any, TProperty : Any> _property(plant: AssertionPlant<T>, property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> _property(plant: AssertionPlant<T>, property: KProperty0<TProperty>, assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction0<TReturnValue>): AssertionPlant<TReturnValue>
fun <T : Any, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction0<TReturnValue>, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction1<T1, TReturnValue>, arg1: T1): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction1<T1, TReturnValue>, arg1: T1, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : CharSequence> _startsNotWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion
fun <T : CharSequence> _startsWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion
fun <T : Any> _toBe(plant: AssertionPlant<T>, expected: T): Assertion
fun _toBeWithErrorTolerance(plant: AssertionPlant<Float>, expected: Float, tolerance: Float): Assertion
fun _toBeWithErrorTolerance(plant: AssertionPlant<Double>, expected: Double, tolerance: Double): Assertion
fun <T : BigDecimal> _toBeWithErrorTolerance(plant: AssertionPlant<T>, expected: T, tolerance: T): Assertion
fun <TExpected : Throwable> _toThrow(throwableThrownBuilder: <ERROR CLASS>, expectedType: KClass<TExpected>, assertionCreator: AssertionPlant<TExpected>.() -> Unit): Unit
fun <T : Any, TSub : Any> _typeTransformation(description: Translatable, representation: Any, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit, warningTransformationFailed: Translatable, canBeTransformed: (T) -> Boolean, transform: (T) -> TSub): Unit

package ch.tutteli.atrium.assertions.any.typetransformation

interface AnyTypeTransformation

interface TypeTransformationFailureHandler<in T : Any, out TSub : Any>

abstract fun createAndAddAssertionToPlant(warningTransformationFailed: Translatable, subjectPlant: BaseAssertionPlant<T?, *>, failingAssertion: Assertion, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit

class DownCaster<T : Any, TSub : T>

DownCaster(failureHandler: TypeTransformationFailureHandler<T, TSub>)
fun downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit

class ExplanatoryTypeTransformationFailureHandler<T : Any, out TSub : T> : TypeTransformationFailureHandler<T, TSub>

ExplanatoryTypeTransformationFailureHandler()
fun createAndAddAssertionToPlant(warningTransformationFailed: Translatable, subjectPlant: BaseAssertionPlant<T?, *>, failingAssertion: Assertion, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit

class TypeTransformer<T : Any, TSub : Any>

TypeTransformer(failureHandler: TypeTransformationFailureHandler<T, TSub>)
fun transform(description: Translatable, representation: Any, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit, warningTransformationFailed: Translatable, canBeTransformed: (T) -> Boolean, transform: (T) -> TSub): Unit

package ch.tutteli.atrium.assertions.basic.contains

interface Contains

interface Checker : Checker
interface Creator<in T : Any, in SC> : Creator<T, SC>
interface SearchBehaviour : SearchBehaviour

package ch.tutteli.atrium.assertions.basic.contains.builders

abstract class ContainsBuilder<out T : Any, out S : SearchBehaviour> : Builder<T, S>

ContainsBuilder(plant: AssertionPlant<T>, searchBehaviour: S)
open val plant: AssertionPlant<T>
open val searchBehaviour: S

interface ContainsCheckerBuilder<out T : Any, out S : SearchBehaviour, out C : Checker, out B : Builder<T, S>> : CheckerOption<T, S, C, B>
fun validateAtMost(times: Int, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String): Unit
fun validateButAtMost(atLeastTimes: Int, butAtMostTimes: Int, atLeastButAtMostCall: (Int, Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String): Unit

package ch.tutteli.atrium.assertions.basic.contains.checkers

abstract class ContainsChecker : Checker

ContainsChecker(times: Int, correctCall: String, wrongCall: (Int) -> String)
protected fun createBasicAssertion(description: Translatable, check: Boolean): DescriptiveAssertion
val times: Int

package ch.tutteli.atrium.assertions.basic.contains.creators

abstract class ContainsAssertionCreator<T : Any, S, C : Checker> : Creator<T, S>

ContainsAssertionCreator(checkers: List<C>)
fun createAssertionGroup(plant: AssertionPlant<T>, searchCriteria: List<S>): AssertionGroup
fun createAssertionGroup(plant: AssertionPlant<T>, searchCriterion: S, otherSearchCriteria: Array<out S>): AssertionGroup
protected abstract fun createAssertionGroupForSearchCriteriaAssertions(assertions: List<Assertion>): AssertionGroup
protected abstract fun searchAndCreateAssertion(plant: AssertionPlant<T>, searchCriterion: S, featureFactory: (numberOfOccurrences: Int, description: Translatable) -> AssertionGroup): AssertionGroup

abstract class ContainsObjectsAssertionCreator<T : Any, S, B : SearchBehaviour, C : Checker> : ContainsAssertionCreator<T, S, C>

ContainsObjectsAssertionCreator(searchBehaviour: B, checkers: List<C>)
protected fun createAssertionGroupForSearchCriteriaAssertions(assertions: List<Assertion>): AssertionGroup
protected abstract val descriptionContains: Translatable
protected abstract val descriptionNumberOfOccurrences: Translatable
protected abstract fun search(plant: AssertionPlant<T>, searchCriterion: S): Int
protected fun searchAndCreateAssertion(plant: AssertionPlant<T>, searchCriterion: S, featureFactory: (Int, Translatable) -> AssertionGroup): AssertionGroup

package ch.tutteli.atrium.assertions.builders

interface AssertionBuilder

open fun createDescriptive(description: Translatable, representation: Any, test: () -> Boolean): DescriptiveAssertion
abstract fun <T : AssertionGroupType> customType(groupType: T): DefaultAssertionGroupBuilderOptions<T>
abstract val descriptive: DescriptiveAssertionHoldsOption
abstract val explanatory: ExplanatoryAssertionExplanationOption
abstract val explanatoryGroup: ExplanatoryAssertionGroupTypeOption
abstract val feature: DefaultAssertionGroupBuilderOptions<FeatureAssertionGroupType>
abstract val list: DefaultAssertionGroupBuilderOptions<ListAssertionGroupType>
abstract val summary: AssertionGroupDescriptionAndEmptyRepresentationOption<SummaryAssertionGroupType, AssertionsOption<SummaryAssertionGroupType, BasicAssertionGroupFinalStep>>

interface AssertionBuilderFinalStep<T : Assertion>

abstract fun build(): T

interface AssertionGroupDescriptionAndEmptyRepresentationOption<out T : AssertionGroupType, R>

fun <T : AssertionGroupType, R> create(type: T, factory: (T, Translatable, Any) -> R): AssertionGroupDescriptionAndEmptyRepresentationOption<T, R>
abstract val groupType: T
abstract fun withDescription(description: Translatable): R

interface AssertionGroupDescriptionAndRepresentationOption<out T : AssertionGroupType, R>

fun <T : AssertionGroupType, R> create(type: T, factory: (T, Translatable, Any) -> R): AssertionGroupDescriptionAndRepresentationOption<T, R>
abstract val groupType: T
open fun withDescriptionAndEmptyRepresentation(description: Translatable): R
open fun withDescriptionAndNullableRepresentation(description: Translatable, representation: Any?): R
open fun withDescriptionAndRepresentation(description: Translatable, representationProvider: () -> Any): R
abstract fun withDescriptionAndRepresentation(description: Translatable, representation: Any): R

interface AssertionsOption<out T : AssertionGroupType, R>

fun <T : AssertionGroupType> asFactoryWithDefaultFinalStep(): (T, Translatable, Any) -> AssertionsOption<T, BasicAssertionGroupFinalStep>
fun <T : AssertionGroupType, R> create(groupType: T, description: Translatable, representation: Any, factory: (T, Translatable, Any, List<Assertion>) -> R): AssertionsOption<T, R>
abstract val description: Translatable
abstract val groupType: T
abstract val representation: Any
open fun withAssertion(assertion: Assertion): R
open fun withAssertions(assertion1: Assertion, assertion2: Assertion): R
open fun withAssertions(assertion1: Assertion, assertion2: Assertion, assertion3: Assertion): R
abstract fun withAssertions(assertions: List<Assertion>): R
fun <T : AssertionGroupType> withDefaultFinalStepAndEmptyDescriptionAndRepresentation(groupType: T): AssertionsOption<T, BasicAssertionGroupFinalStep>
fun <T : AssertionGroupType, R> withEmptyDescriptionAndRepresentation(groupType: T, factory: (T, Translatable, Any, List<Assertion>) -> R): AssertionsOption<T, R>

interface BasicAssertionGroupFinalStep : AssertionBuilderFinalStep<AssertionGroup>

abstract val assertions: List<Assertion>
fun create(groupType: AssertionGroupType, description: Translatable, representation: Any, assertions: List<Assertion>): BasicAssertionGroupFinalStep
abstract val description: Translatable
abstract val groupType: AssertionGroupType
abstract val representation: Any

typealias DefaultAssertionGroupBuilderOptions<T> = AssertionGroupDescriptionAndRepresentationOption<T, AssertionsOption<T, BasicAssertionGroupFinalStep>>
interface DescriptiveAssertionFinalStep : AssertionBuilderFinalStep<DescriptiveAssertion>

fun create(test: () -> Boolean, description: Translatable, representation: Any): DescriptiveAssertionFinalStep
abstract val description: Translatable
abstract val representation: Any
abstract val test: () -> Boolean

interface DescriptiveAssertionHoldsOption

abstract val failing: DescriptiveLikeAssertionDescriptionOption<DescriptiveAssertionFinalStep>
abstract val holding: DescriptiveLikeAssertionDescriptionOption<DescriptiveAssertionFinalStep>
abstract fun withTest(test: () -> Boolean): DescriptiveLikeAssertionDescriptionOption<DescriptiveAssertionFinalStep>

interface DescriptiveLikeAssertionDescriptionOption<R>

fun <R> create(test: () -> Boolean, factory: (() -> Boolean, Translatable, Any) -> R): DescriptiveLikeAssertionDescriptionOption<R>
abstract val test: () -> Boolean
open fun withDescriptionAndNullableRepresentation(description: Translatable, representation: Any?): R
abstract fun withDescriptionAndRepresentation(description: Translatable, representation: Any): R

interface ExplanatoryAssertionExplanationOption

open fun withDescription(translatable: Translatable, arg: Any, vararg otherArgs: Any): ExplanatoryAssertionFinalStep
open fun withDescription(translatable: Translatable): ExplanatoryAssertionFinalStep
abstract fun withDescription(explanation: Any?): ExplanatoryAssertionFinalStep

interface ExplanatoryAssertionFinalStep : AssertionBuilderFinalStep<ExplanatoryAssertion>

fun create(explanation: Any?): ExplanatoryAssertionFinalStep
abstract val explanation: Any?

interface ExplanatoryAssertionGroupFinalStep : AssertionBuilderFinalStep<AssertionGroup>

fun create(groupType: ExplanatoryAssertionGroupType, explanatoryAssertions: List<Assertion>): ExplanatoryAssertionGroupFinalStep
abstract val explanatoryAssertions: List<Assertion>
abstract val groupType: ExplanatoryAssertionGroupType

interface ExplanatoryAssertionGroupTypeOption

abstract val withDefaultType: AssertionsOption<DefaultExplanatoryAssertionGroupType, ExplanatoryAssertionGroupFinalStep>
abstract fun <T : ExplanatoryAssertionGroupType> withType(groupType: T): AssertionsOption<T, ExplanatoryAssertionGroupFinalStep>
abstract val withWarningType: AssertionsOption<WarningAssertionGroupType, ExplanatoryAssertionGroupFinalStep>

val assertionBuilder: AssertionBuilder
val AssertionBuilder.invisibleGroup: AssertionsOption<InvisibleAssertionGroupType, BasicAssertionGroupFinalStep>
val AssertionBuilder.root: DefaultAssertionGroupBuilderOptions<RootAssertionGroupType>
fun <T : ExplanatoryAssertionGroupType> AssertionsOption<T, ExplanatoryAssertionGroupFinalStep>.withExplanatoryAssertion(translatable: Translatable): ExplanatoryAssertionGroupFinalStep
fun <T : ExplanatoryAssertionGroupType> AssertionsOption<T, ExplanatoryAssertionGroupFinalStep>.withExplanatoryAssertions(translatable: Translatable, arg: Any, vararg otherArgs: Any): ExplanatoryAssertionGroupFinalStep

package ch.tutteli.atrium.assertions.charsequence.contains

interface CharSequenceContains

interface Checker : Checker, Checker
interface Creator<in T : CharSequence, in SC> : Creator<T, SC>, Creator<T, SC>
interface SearchBehaviour : SearchBehaviour, SearchBehaviour
interface Searcher<S : SearchBehaviour> : Searcher<S>

package ch.tutteli.atrium.assertions.charsequence.contains.builders

abstract class CharSequenceContainsAtLeastCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtLeastCheckerBuilderBase(times: Int, containsBuilder: Builder<T, S>, nameContainsNotFun: String, atLeastCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: Builder<T, S>
val times: Int

abstract class CharSequenceContainsAtMostCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtMostCheckerBuilderBase(times: Int, containsBuilder: Builder<T, S>, nameContainsNotFun: String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: Builder<T, S>
val times: Int

class CharSequenceContainsBuilder<out T : CharSequence, out S : SearchBehaviour> : ContainsBuilder<T, S>, Builder<T, S>

CharSequenceContainsBuilder(plant: AssertionPlant<T>, searchBehaviour: S)

abstract class CharSequenceContainsButAtMostCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsButAtMostCheckerBuilderBase(times: Int, atLeastBuilder: CharSequenceContainsAtLeastCheckerBuilderBase<T, S>, containsBuilder: Builder<T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: Builder<T, S>
val times: Int

interface CharSequenceContainsCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ContainsCheckerBuilder<T, S, Checker, Builder<T, S>>, CheckerOption<T, S>
abstract class CharSequenceContainsExactlyCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsExactlyCheckerBuilderBase(times: Int, containsBuilder: Builder<T, S>, nameContainsNotFun: String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: Builder<T, S>
val times: Int

abstract class CharSequenceContainsNotCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotCheckerBuilderBase(containsBuilder: Builder<T, S>)
open val checkers: <ERROR CLASS>
open val containsBuilder: Builder<T, S>

abstract class CharSequenceContainsNotOrAtMostCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotOrAtMostCheckerBuilderBase(times: Int, containsBuilder: Builder<T, S>, nameContainsNotFun: String, notOrAtMostCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: Builder<T, S>
val times: Int

package ch.tutteli.atrium.assertions.charsequence.contains.checkers

class CharSequenceContainsAtLeastChecker : CharSequenceContainsChecker

CharSequenceContainsAtLeastChecker(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

class CharSequenceContainsAtMostChecker : CharSequenceContainsChecker

CharSequenceContainsAtMostChecker(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

abstract class CharSequenceContainsChecker : ContainsChecker, Checker

CharSequenceContainsChecker(times: Int, correctCall: String, wrongCall: (Int) -> String)

class CharSequenceContainsExactlyChecker : CharSequenceContainsChecker

CharSequenceContainsExactlyChecker(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

class CharSequenceContainsNotChecker : Checker

CharSequenceContainsNotChecker()
fun createAssertion(foundNumberOfTimes: Int): Assertion

package ch.tutteli.atrium.assertions.charsequence.contains.creators

class CharSequenceContainsAssertionCreator<T : CharSequence, S : SearchBehaviour> : ContainsObjectsAssertionCreator<T, Any, S, Checker>, Creator<T, Any>

CharSequenceContainsAssertionCreator(searchBehaviour: S, searcher: Searcher<S>, checkers: List<Checker>)
protected val descriptionContains: DescriptionCharSequenceAssertion
protected val descriptionNumberOfOccurrences: DescriptionCharSequenceAssertion
protected fun search(plant: AssertionPlant<T>, searchCriterion: Any): Int

fun <T : CharSequence> _containsDefaultTranslationOf(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsNoOpSearchBehaviour>, expected: Translatable, otherExpected: Array<out Translatable>): AssertionGroup
fun <T : CharSequence> _containsDefaultTranslationOfIgnoringCase(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsIgnoringCaseSearchBehaviour>, expected: Translatable, otherExpected: Array<out Translatable>): AssertionGroup
fun <T : CharSequence> _containsRegex(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsNoOpSearchBehaviour>, expected: String, otherExpected: Array<out String>): AssertionGroup
fun <T : CharSequence> _containsRegexIgnoringCase(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsIgnoringCaseSearchBehaviour>, expected: String, otherExpected: Array<out String>): AssertionGroup
fun <T : CharSequence> _containsValues(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsNoOpSearchBehaviour>, expected: Any, otherExpected: Array<out Any>): AssertionGroup
fun <T : CharSequence> _containsValuesIgnoringCase(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsIgnoringCaseSearchBehaviour>, expected: Any, otherExpected: Array<out Any>): AssertionGroup

package ch.tutteli.atrium.assertions.charsequence.contains.searchbehaviours

open class CharSequenceContainsIgnoringCaseSearchBehaviour : SearchBehaviour, IgnoringCaseSearchBehaviour

CharSequenceContainsIgnoringCaseSearchBehaviour(previousBehaviour: NoOpSearchBehaviour)
open fun decorateDescription(description: Translatable): Translatable

open class CharSequenceContainsNoOpSearchBehaviour : SearchBehaviour, NoOpSearchBehaviour

CharSequenceContainsNoOpSearchBehaviour()

open class CharSequenceContainsNotSearchBehaviour : CharSequenceContainsNoOpSearchBehaviour, NotSearchBehaviour

CharSequenceContainsNotSearchBehaviour()
open fun decorateDescription(description: Translatable): DescriptionCharSequenceAssertion

fun <T : CharSequence> _containsIgnoringCase(containsBuilder: CharSequenceContainsBuilder<T, CharSequenceContainsNoOpSearchBehaviour>): CharSequenceContainsBuilder<T, CharSequenceContainsIgnoringCaseSearchBehaviour>

package ch.tutteli.atrium.assertions.charsequence.contains.searchers

class CharSequenceContainsIgnoringCaseIndexSearcher : Searcher<CharSequenceContainsIgnoringCaseSearchBehaviour>

CharSequenceContainsIgnoringCaseIndexSearcher()
fun search(searchIn: CharSequence, searchFor: Any): Int

class CharSequenceContainsIgnoringCaseRegexSearcher : Searcher<CharSequenceContainsIgnoringCaseSearchBehaviour>

CharSequenceContainsIgnoringCaseRegexSearcher()
fun search(searchIn: CharSequence, searchFor: Any): Int

class CharSequenceContainsIndexSearcher : Searcher<CharSequenceContainsNoOpSearchBehaviour>

CharSequenceContainsIndexSearcher()
fun search(searchIn: CharSequence, searchFor: Any): Int

class CharSequenceContainsRegexSearcher : Searcher<CharSequenceContainsNoOpSearchBehaviour>

CharSequenceContainsRegexSearcher()
fun search(searchIn: CharSequence, searchFor: Any): Int
fun search(searchIn: CharSequence, pattern: Pattern): Int

package ch.tutteli.atrium.assertions.iterable.contains

interface IterableContains

interface Checker : Checker, Checker
interface Creator<in T : Iterable<*>, in S> : Creator<T, S>, Creator<T, S>
interface SearchBehaviour : SearchBehaviour, SearchBehaviour

package ch.tutteli.atrium.assertions.iterable.contains.builders

abstract class IterableContainsAtLeastCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsAtLeastCheckerBuilderBase(times: Int, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, atLeastCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int

abstract class IterableContainsAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsAtMostCheckerBuilderBase(times: Int, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int

open class IterableContainsBuilder<out E, out T : Iterable<E>, out S : SearchBehaviour> : ContainsBuilder<T, S>, Builder<E, T, S>

IterableContainsBuilder(plant: AssertionPlant<T>, searchBehaviour: S)

abstract class IterableContainsButAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsButAtMostCheckerBuilderBase(times: Int, atLeastBuilder: IterableContainsAtLeastCheckerBuilderBase<E, T, S>, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int

interface IterableContainsCheckerBuilder<out E, out T : Iterable<E>, out S : SearchBehaviour> : ContainsCheckerBuilder<T, S, Checker, Builder<E, T, S>>, CheckerOption<E, T, S>
abstract class IterableContainsExactlyCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsExactlyCheckerBuilderBase(times: Int, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int

class IterableContainsNoOpCheckerBuilder<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsNoOpCheckerBuilder(containsBuilder: IterableContainsBuilder<E, T, S>)
val checkers: List<Checker>
val containsBuilder: IterableContainsBuilder<E, T, S>

abstract class IterableContainsNotCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsNotCheckerBuilderBase(containsBuilder: IterableContainsBuilder<E, T, S>)
open val checkers: <ERROR CLASS>
open val containsBuilder: IterableContainsBuilder<E, T, S>

abstract class IterableContainsNotOrAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsNotOrAtMostCheckerBuilderBase(times: Int, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, notOrAtMostCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int

package ch.tutteli.atrium.assertions.iterable.contains.checkers

class IterableContainsAtLeastChecker : IterableContainsChecker

IterableContainsAtLeastChecker(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

class IterableContainsAtMostChecker : IterableContainsChecker

IterableContainsAtMostChecker(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

abstract class IterableContainsChecker : ContainsChecker, Checker

IterableContainsChecker(times: Int, correctCall: String, wrongCall: (Int) -> String)

class IterableContainsExactlyChecker : IterableContainsChecker

IterableContainsExactlyChecker(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

class IterableContainsNotChecker : Checker

IterableContainsNotChecker()
fun createAssertion(foundNumberOfTimes: Int): Assertion

package ch.tutteli.atrium.assertions.iterable.contains.creators

open class IterableContainsInAnyOrderEntriesAssertionCreator<E : Any, T : Iterable<E?>> : ContainsAssertionCreator<T, AssertionPlant<E>.() -> Unit, Checker>, Creator<T, AssertionPlant<E>.() -> Unit>

IterableContainsInAnyOrderEntriesAssertionCreator(searchBehaviour: IterableContainsInAnyOrderSearchBehaviour, checkers: List<Checker>)
protected fun createAssertionGroupForSearchCriteriaAssertions(assertions: List<Assertion>): AssertionGroup
protected fun searchAndCreateAssertion(plant: AssertionPlant<T>, searchCriterion: AssertionPlant<E>.() -> Unit, featureFactory: (Int, Translatable) -> AssertionGroup): AssertionGroup

class IterableContainsInAnyOrderObjectsAssertionCreator<S, T : Iterable<S>> : ContainsObjectsAssertionCreator<T, S, IterableContainsInAnyOrderSearchBehaviour, Checker>, Creator<T, S>

IterableContainsInAnyOrderObjectsAssertionCreator(searchBehaviour: IterableContainsInAnyOrderSearchBehaviour, checkers: List<Checker>)
protected val descriptionContains: DescriptionIterableAssertion
protected val descriptionNumberOfOccurrences: DescriptionIterableAssertion
protected fun search(plant: AssertionPlant<T>, searchCriterion: S): Int

abstract class IterableContainsInAnyOrderOnlyAssertionCreator<E, T : Iterable<E?>, SC> : Creator<T, SC>

IterableContainsInAnyOrderOnlyAssertionCreator(searchBehaviour: IterableContainsInAnyOrderOnlySearchBehaviour)
protected abstract fun createAssertionForSearchCriterionAndRemoveMatchFromList(searchCriterion: SC, list: MutableList<E?>): <ERROR CLASS><Boolean, Assertion>
fun createAssertionGroup(plant: AssertionPlant<T>, searchCriterion: SC, otherSearchCriteria: Array<out SC>): AssertionGroup
fun createAssertionGroup(plant: AssertionPlant<T>, searchCriteria: List<SC>): AssertionGroup

class IterableContainsInAnyOrderOnlyEntriesAssertionCreator<E : Any, T : Iterable<E?>> : IterableContainsInAnyOrderOnlyAssertionCreator<E, T, AssertionPlant<E>.() -> Unit>

IterableContainsInAnyOrderOnlyEntriesAssertionCreator(searchBehaviour: IterableContainsInAnyOrderOnlySearchBehaviour)
protected fun createAssertionForSearchCriterionAndRemoveMatchFromList(searchCriterion: AssertionPlant<E>.() -> Unit, list: MutableList<E?>): <ERROR CLASS><Boolean, Assertion>

class IterableContainsInAnyOrderOnlyObjectsAssertionCreator<E, T : Iterable<E?>> : IterableContainsInAnyOrderOnlyAssertionCreator<E, T, E>

IterableContainsInAnyOrderOnlyObjectsAssertionCreator(searchBehaviour: IterableContainsInAnyOrderOnlySearchBehaviour)
protected fun createAssertionForSearchCriterionAndRemoveMatchFromList(searchCriterion: E, list: MutableList<E?>): <ERROR CLASS><Boolean, Assertion>

abstract class IterableContainsInOrderOnlyAssertionCreator<E, T : Iterable<E?>, SC> : Creator<T, SC>

IterableContainsInOrderOnlyAssertionCreator(searchBehaviour: IterableContainsInOrderOnlySearchBehaviour)
fun createAssertionGroup(plant: AssertionPlant<T>, searchCriterion: SC, otherSearchCriteria: Array<out SC>): AssertionGroup
fun createAssertionGroup(plant: AssertionPlant<T>, searchCriteria: List<SC>): AssertionGroup
abstract fun createEntryAssertion(iterableAsList: List<E?>, searchCriterion: SC, template: ((Boolean) -> Assertion) -> AssertionGroup): AssertionGroup
abstract fun matches(actual: E?, searchCriterion: SC): Boolean

class IterableContainsInOrderOnlyEntriesAssertionCreator<E : Any, T : Iterable<E?>> : IterableContainsInOrderOnlyAssertionCreator<E, T, AssertionPlant<E>.() -> Unit>

IterableContainsInOrderOnlyEntriesAssertionCreator(searchBehaviour: IterableContainsInOrderOnlySearchBehaviour)
fun createEntryAssertion(iterableAsList: List<E?>, searchCriterion: AssertionPlant<E>.() -> Unit, template: ((Boolean) -> Assertion) -> AssertionGroup): AssertionGroup
fun matches(actual: E?, searchCriterion: AssertionPlant<E>.() -> Unit): Boolean

class IterableContainsInOrderOnlyObjectsAssertionCreator<E, T : Iterable<E?>> : IterableContainsInOrderOnlyAssertionCreator<E, T, E>

IterableContainsInOrderOnlyObjectsAssertionCreator(searchBehaviour: IterableContainsInOrderOnlySearchBehaviour)
fun createEntryAssertion(iterableAsList: List<E?>, searchCriterion: E, template: ((Boolean) -> Assertion) -> AssertionGroup): AssertionGroup
fun matches(actual: E?, searchCriterion: E): Boolean

fun <E : Any, T : Iterable<E>> _containsEntriesInAnyOrder(checker: IterableContainsCheckerBuilder<E, T, IterableContainsInAnyOrderSearchBehaviour>, assertionCreator: AssertionPlant<E>.() -> Unit, otherAssertionCreators: Array<AssertionPlant<E>.() -> Unit>): Assertion
fun <E : Any, T : Iterable<E>> _containsEntriesInAnyOrderOnly(builder: IterableContainsBuilder<E, T, IterableContainsInAnyOrderOnlySearchBehaviour>, assertionCreator: AssertionPlant<E>.() -> Unit, otherAssertionCreators: Array<AssertionPlant<E>.() -> Unit>): Assertion
fun <E : Any, T : Iterable<E>> _containsEntriesInOrderOnly(builder: IterableContainsBuilder<E, T, IterableContainsInOrderOnlySearchBehaviour>, assertionCreator: AssertionPlant<E>.() -> Unit, otherAssertionCreators: Array<AssertionPlant<E>.() -> Unit>): Assertion
fun <E, T : Iterable<E>> _containsObjectsInAnyOrder(checker: IterableContainsCheckerBuilder<E, T, IterableContainsInAnyOrderSearchBehaviour>, expected: E, otherExpected: Array<out E>): Assertion
fun <E, T : Iterable<E>> _containsObjectsInAnyOrderOnly(builder: IterableContainsBuilder<E, T, IterableContainsInAnyOrderOnlySearchBehaviour>, expected: E, otherExpected: Array<out E>): Assertion
fun <E, T : Iterable<E>> _containsObjectsInOrderOnly(builder: IterableContainsBuilder<E, T, IterableContainsInOrderOnlySearchBehaviour>, expected: E, otherExpected: Array<out E>): Assertion

package ch.tutteli.atrium.assertions.iterable.contains.searchbehaviours

open class IterableContainsInAnyOrderOnlySearchBehaviour : SearchBehaviour, InAnyOrderOnlySearchBehaviour

IterableContainsInAnyOrderOnlySearchBehaviour()
open fun decorateDescription(description: Translatable): Translatable

open class IterableContainsInAnyOrderSearchBehaviour : SearchBehaviour, InAnyOrderSearchBehaviour

IterableContainsInAnyOrderSearchBehaviour()
open fun decorateDescription(description: Translatable): Translatable

open class IterableContainsInOrderOnlySearchBehaviour : SearchBehaviour, InOrderOnlySearchBehaviour

IterableContainsInOrderOnlySearchBehaviour()
open fun decorateDescription(description: Translatable): Translatable

open class IterableContainsInOrderSearchBehaviour : SearchBehaviour, InOrderSearchBehaviour

IterableContainsInOrderSearchBehaviour()
open fun decorateDescription(description: Translatable): Translatable

open class IterableContainsNoOpSearchBehaviour : SearchBehaviour, NoOpSearchBehaviour

IterableContainsNoOpSearchBehaviour()

open class IterableContainsNotSearchBehaviour : IterableContainsInAnyOrderSearchBehaviour, NotSearchBehaviour

IterableContainsNotSearchBehaviour()
open fun decorateDescription(description: Translatable): Translatable

fun <E, T : Iterable<E>> _containsInAnyOrder(containsBuilder: IterableContainsBuilder<E, T, IterableContainsNoOpSearchBehaviour>): IterableContainsBuilder<E, T, IterableContainsInAnyOrderSearchBehaviour>
fun <E, T : Iterable<E>> _containsInAnyOrderOnly(containsBuilder: IterableContainsBuilder<E, T, IterableContainsInAnyOrderSearchBehaviour>): IterableContainsBuilder<E, T, IterableContainsInAnyOrderOnlySearchBehaviour>
fun <E, T : Iterable<E>> _containsInOrder(containsBuilder: IterableContainsBuilder<E, T, IterableContainsNoOpSearchBehaviour>): IterableContainsBuilder<E, T, IterableContainsInOrderSearchBehaviour>
fun <E, T : Iterable<E>> _containsInOrderOnly(containsBuilder: IterableContainsBuilder<E, T, IterableContainsInOrderSearchBehaviour>): IterableContainsBuilder<E, T, IterableContainsInOrderOnlySearchBehaviour>

package ch.tutteli.atrium.assertions.throwable.thrown

interface ThrowableThrown

interface AbsentThrowableMessageProvider

abstract val message: RawString

interface Creator<TExpected : Throwable>

abstract fun executeActAndCreateAssertion(throwableThrownBuilder: ThrowableThrownBuilder, description: Translatable, expectedType: KClass<TExpected>, assertionCreator: AssertionPlant<TExpected>.() -> Unit): Unit

package ch.tutteli.atrium.assertions.throwable.thrown.builders

class ThrowableThrownBuilder : Builder

ThrowableThrownBuilder(assertionVerb: Translatable, act: () -> Unit, reporter: Reporter)
val act: () -> Unit
val assertionVerb: Translatable
val reporter: Reporter

package ch.tutteli.atrium.assertions.throwable.thrown.creators

class ThrowableThrownAssertionCreator<TExpected : Throwable> : Creator<TExpected>

ThrowableThrownAssertionCreator(absentThrowableMessageProvider: AbsentThrowableMessageProvider, failureHandler: TypeTransformationFailureHandler<Throwable, TExpected>)
fun executeActAndCreateAssertion(throwableThrownBuilder: ThrowableThrownBuilder, description: Translatable, expectedType: KClass<TExpected>, assertionCreator: AssertionPlant<TExpected>.() -> Unit): Unit

package ch.tutteli.atrium.assertions.throwable.thrown.providers

class TranslatableAsAbsentThrowableMessageProvider : AbsentThrowableMessageProvider

TranslatableAsAbsentThrowableMessageProvider(translatable: Translatable)
val message: RawString

package ch.tutteli.atrium.checking

interface AssertionChecker

abstract fun check(assertionVerb: Translatable, representationProvider: () -> Any, assertions: List<Assertion>): Unit

package ch.tutteli.atrium.core

interface CoreFactory

abstract fun newAssertionFormatterController(): AssertionFormatterController
abstract fun newAssertionFormatterFacade(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacade
abstract fun <T : Any> newCheckingPlant(subjectProvider: () -> T): CheckingAssertionPlant<T>
abstract fun <T : Any> newCollectingPlant(subjectProvider: () -> T): CollectingAssertionPlant<T>
abstract fun <T> newDelegatingAssertionChecker(subjectPlant: BaseAssertionPlant<T, *>): AssertionChecker
abstract fun newDetailedObjectFormatter(translator: Translator): ObjectFormatter
abstract fun <T : Any> newFeatureAssertionChecker(subjectPlant: AssertionPlant<T>): AssertionChecker
abstract fun newLocaleOrderDecider(): LocaleOrderDecider
abstract fun newMethodCallFormatter(): MethodCallFormatter
abstract fun newOnlyFailureReporter(assertionFormatterFacade: AssertionFormatterFacade): Reporter
abstract fun newPropertiesBasedTranslationSupplier(): TranslationSupplier
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subjectProvider: () -> T, assertionChecker: AssertionChecker): ReportingAssertionPlant<T>
abstract fun <T : Any> newReportingPlant(commonFields: CommonFields<T>): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlantAndAddAssertionsCreatedBy(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter, assertionCreator: AssertionPlant<T>.() -> Unit): AssertionPlant<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter, nullRepresentation: Any = RawString.NULL): ReportingAssertionPlantNullable<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subjectProvider: () -> T, assertionChecker: AssertionChecker, nullRepresentation: Any = RawString.NULL): ReportingAssertionPlantNullable<T>
abstract fun <T> newReportingPlantNullable(commonFields: CommonFields<T>): ReportingAssertionPlantNullable<T>
abstract fun newTextExplanatoryAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController): AssertionFormatter
abstract fun newTextFallbackAssertionFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextFeatureAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextListAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextSameLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newTextSummaryAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newThrowingAssertionChecker(reporter: Reporter): AssertionChecker
abstract fun newTranslator(translationSupplier: TranslationSupplier, localeOrderDecider: LocaleOrderDecider, primaryLocale: Locale, fallbackLocales: List<Locale>): Translator
abstract fun registerTextAssertionFormatterCapabilities(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterFacade: AssertionFormatterFacade, textAssertionPairFormatter: AssertionPairFormatter, objectFormatter: ObjectFormatter, translator: Translator): Unit

object SingleServiceLoader

fun <T : Any> load(clazz: Class<T>): T

val coreFactory: <ERROR CLASS>
val falseProvider: () -> Boolean
kotlin.Function0

fun <T> (() -> T).evalOnce(): () -> T

val trueProvider: () -> Boolean

package ch.tutteli.atrium.creating

typealias Assert<T> = AssertionPlant<T>
@DslMarker annotation class AssertMarker

AssertMarker()

interface AssertionPlant<out T : Any> : BaseAssertionPlant<T, AssertionPlant<T>>

abstract fun addAssertionsCreatedBy(assertionCreator: AssertionPlant<T>.() -> Unit): AssertionPlant<T>
open fun createAndAddAssertion(description: Translatable, expected: Any, test: () -> Boolean): AssertionPlant<T>

interface AssertionPlantNullable<out T> : BaseAssertionPlant<T, AssertionPlantNullable<T>>
interface AssertionPlantWithCommonFields<out T>

class CommonFields<out T>

CommonFields(assertionVerb: Translatable, subject: T, assertionChecker: AssertionChecker, nullRepresentation: Any)
CommonFields(assertionVerb: Translatable, subjectProvider: () -> T, representationProvider: () -> Any?, assertionChecker: AssertionChecker, nullRepresentation: Any)
val assertionChecker: AssertionChecker
val assertionVerb: Translatable
fun check(assertions: List<Assertion>): Unit
val representation: () -> Any
val subjectProvider: () -> T

abstract val commonFields: CommonFields<T>

interface BaseAssertionPlant<out T, out A : BaseAssertionPlant<T, A>>

abstract fun addAssertion(assertion: Assertion): A
abstract val subject: T
abstract val subjectProvider: () -> T

interface BaseReportingAssertionPlant<out T, out A : BaseAssertionPlant<T, A>> : BaseAssertionPlant<T, A>, AssertionPlantWithCommonFields<T>
interface CheckingAssertionPlant<out T : Any> : AssertionPlant<T>

abstract fun addAssertionsCreatedBy(assertionCreator: AssertionPlant<T>.() -> Unit): CheckingAssertionPlant<T>
abstract fun allAssertionsHold(): Boolean

interface CollectingAssertionPlant<out T : Any> : AssertionPlant<T>

abstract fun addAssertionsCreatedBy(assertionCreator: AssertionPlant<T>.() -> Unit): CollectingAssertionPlant<T>
abstract fun getAssertions(): List<Assertion>
abstract val subject: T

class PlantHasNoSubjectException : RuntimeException

PlantHasNoSubjectException()
PlantHasNoSubjectException(message: String)

interface ReportingAssertionPlant<out T : Any> : AssertionPlant<T>, BaseReportingAssertionPlant<T, AssertionPlant<T>>
interface ReportingAssertionPlantNullable<out T> : AssertionPlantNullable<T>, BaseReportingAssertionPlant<T, AssertionPlantNullable<T>>

package ch.tutteli.atrium.domain.assertions.composers

interface AssertionComposer

abstract fun createDescriptiveWithFailureHint(description: Translatable, representation: Any, test: () -> Boolean, showHint: () -> Boolean, failureHintFactory: () -> Assertion): Assertion

val assertionComposer: <ERROR CLASS>

package ch.tutteli.atrium.domain.builders

object AssertImpl

inline val any: AnyAssertionsBuilder
inline val bigDecimal: BigDecimalAssertionsBuilder
inline val builder: AssertionBuilder
fun <T, R : Any> changeSubject(originalPlant: BaseAssertionPlant<T, *>, subjectProvider: () -> R): AssertionPlant<R>
inline val charSequence: CharSequenceAssertionsBuilder
inline val collection: CollectionAssertionsBuilder
inline val collector: AssertionCollectorBuilder
inline val comparable: ComparableAssertionsBuilder
inline val coreFactory: <ERROR CLASS>
inline val feature: FeatureAssertionsBuilder
inline val floatingPoint: FloatingPointAssertionsBuilder
inline val iterable: IterableAssertionsBuilder
inline val map: MapAssertionsBuilder
inline val throwable: ThrowableAssertionsBuilder

package ch.tutteli.atrium.domain.builders.assertions.builders

interface DescriptiveAssertionWithFailureHintFinalStep : AssertionBuilderFinalStep<Assertion>

fun create(test: () -> Boolean, showHint: () -> Boolean, failureHintFactory: () -> Assertion, description: Translatable, representation: Any): DescriptiveAssertionWithFailureHintFinalStep
abstract val description: Translatable
abstract val failureHintFactory: () -> Assertion
abstract val representation: Any
abstract val showHint: () -> Boolean
abstract val test: () -> Boolean

interface DescriptiveAssertionWithFailureHintShowOption

fun create(test: () -> Boolean, failureHintFactory: () -> Assertion): DescriptiveAssertionWithFailureHintShowOption
abstract val showForAnyFailure: DescriptiveLikeAssertionDescriptionOption<DescriptiveAssertionWithFailureHintFinalStep>
abstract fun showOnlyIf(predicate: () -> Boolean): DescriptiveLikeAssertionDescriptionOption<DescriptiveAssertionWithFailureHintFinalStep>

interface FixedClaimAssertionGroupFinalStep : BasicAssertionGroupFinalStep

fun create(groupType: AssertionGroupType, description: Translatable, representation: Any, assertions: List<Assertion>, holds: Boolean): FixedClaimAssertionGroupFinalStep
abstract val holds: Boolean

interface FixedClaimAssertionGroupHoldsOption<T : AssertionGroupType>

fun <T : AssertionGroupType> create(groupType: T): FixedClaimAssertionGroupHoldsOption<T>
abstract val failing: AssertionGroupDescriptionAndRepresentationOption<T, AssertionsOption<T, FixedClaimAssertionGroupFinalStep>>
abstract val groupType: T
abstract val holding: AssertionGroupDescriptionAndRepresentationOption<T, AssertionsOption<T, FixedClaimAssertionGroupFinalStep>>
abstract fun withClaim(holds: Boolean): AssertionGroupDescriptionAndRepresentationOption<T, AssertionsOption<T, FixedClaimAssertionGroupFinalStep>>

interface FixedClaimAssertionGroupTypeOption

abstract val withListType: FixedClaimAssertionGroupHoldsOption<ListAssertionGroupType>
abstract fun <T : AssertionGroupType> withType(type: T): FixedClaimAssertionGroupHoldsOption<T>

val AssertionBuilder.fixedClaimGroup: FixedClaimAssertionGroupTypeOption
fun DescriptiveLikeAssertionDescriptionOption<DescriptiveAssertionFinalStep>.withFailureHint(failureHintFactory: () -> Assertion): DescriptiveAssertionWithFailureHintShowOption

package ch.tutteli.atrium.domain.builders.creating

object AbsentThrowableMessageProviderFactoryBuilder : AbsentThrowableMessageProviderFactory

inline fun translatableBased(translatable: Translatable): AbsentThrowableMessageProvider

object AnyAssertionsBuilder : AnyAssertions

inline fun <T : Any> isNotSame(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
inline fun <T> isNull(plant: AssertionPlantNullable<T>): <ERROR CLASS>
inline fun <T : Any> isSame(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
inline fun <T : Any> notToBe(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
inline fun <T : Any> toBe(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
inline val typeTransformation: AnyTypeTransformationAssertionsBuilder

object AnyTypeTransformationAssertionsBuilder : AnyTypeTransformationAssertions

inline fun <T : Any, TSub : T> downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, noinline assertionCreator: AssertionPlant<TSub>.() -> Unit, failureHandler: FailureHandler<T, TSub>): <ERROR CLASS>
inline val failureHandlers: AnyTypeTransformationFailureHandlerFactoryBuilder
inline fun <TSub : Any> isA(plant: AssertionPlant<Any>, subType: KClass<TSub>, noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): <ERROR CLASS>
inline fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, noinline assertionCreator: AssertionPlant<T>.() -> Unit): <ERROR CLASS>
inline fun <S : Any, T : Any> transform(parameterObject: ParameterObject<S, T>, noinline canBeTransformed: (S) -> Boolean, noinline transform: (S) -> T, failureHandler: FailureHandler<S, T>): <ERROR CLASS>

object AnyTypeTransformationFailureHandlerFactoryBuilder : FailureHandlerFactory

inline fun <S : Any, T : Any> newExplanatory(): <ERROR CLASS>
inline fun <S : Any, T : Any> newExplanatoryWithHint(noinline showHint: () -> Boolean, noinline failureHintFactory: () -> Assertion): <ERROR CLASS>

object BigDecimalAssertionsBuilder : BigDecimalAssertions

inline fun <T : BigDecimal> isEqualIncludingScale(plant: AssertionPlant<T>, expected: T, nameOfIsNumericallyEqualTo: String): <ERROR CLASS>
inline fun <T : BigDecimal> isNotEqualIncludingScale(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
inline fun <T : BigDecimal> isNotNumericallyEqualTo(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
inline fun <T : BigDecimal> isNumericallyEqualTo(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>

object CharSequenceAssertionsBuilder : CharSequenceAssertions

inline val contains: CharSequenceContainsAssertionsBuilder
inline fun <T : CharSequence> containsBuilder(plant: AssertionPlant<T>): <ERROR CLASS>
inline fun <T : CharSequence> containsNotBuilder(plant: AssertionPlant<T>): <ERROR CLASS>
inline fun <T : CharSequence> endsNotWith(plant: AssertionPlant<T>, expected: CharSequence): <ERROR CLASS>
inline fun <T : CharSequence> endsWith(plant: AssertionPlant<T>, expected: CharSequence): <ERROR CLASS>
inline fun <T : CharSequence> isEmpty(plant: AssertionPlant<T>): <ERROR CLASS>
inline fun <T : CharSequence> isNotEmpty(plant: AssertionPlant<T>): <ERROR CLASS>
inline fun <T : CharSequence> startsNotWith(plant: AssertionPlant<T>, expected: CharSequence): <ERROR CLASS>
inline fun <T : CharSequence> startsWith(plant: AssertionPlant<T>, expected: CharSequence): <ERROR CLASS>

object CharSequenceContainsAssertionsBuilder : CharSequenceContainsAssertions

inline fun <T : CharSequence> defaultTranslationOf(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Translatable>): <ERROR CLASS>
inline fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Translatable>): <ERROR CLASS>
inline fun <T : CharSequence> regex(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<String>): <ERROR CLASS>
inline fun <T : CharSequence> regexIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<String>): <ERROR CLASS>
inline val searchBehaviours: CharSequenceContainsSearchBehaviourFactoryBuilder
inline fun <T : CharSequence> values(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Any>): <ERROR CLASS>
inline fun <T : CharSequence> valuesIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Any>): <ERROR CLASS>

object CharSequenceContainsSearchBehaviourFactoryBuilder : SearchBehaviourFactory

inline fun <T : CharSequence> ignoringCase(containsBuilder: Builder<T, NoOpSearchBehaviour>): Builder<T, IgnoringCaseSearchBehaviour>

object CollectionAssertionsBuilder : CollectionAssertions

inline fun <T : Collection<*>> hasSize(plant: AssertionPlant<T>, size: Int): <ERROR CLASS>
inline fun <T : Collection<*>> isEmpty(plant: AssertionPlant<T>): <ERROR CLASS>
inline fun <T : Collection<*>> isNotEmpty(plant: AssertionPlant<T>): <ERROR CLASS>

object ComparableAssertionsBuilder : ComparableAssertions

inline fun <T1 : Comparable<T2>, T2> isGreaterOrEquals(plant: AssertionPlant<T1>, expected: T2): <ERROR CLASS>
inline fun <T1 : Comparable<T2>, T2> isGreaterThan(plant: AssertionPlant<T1>, expected: T2): <ERROR CLASS>
inline fun <T1 : Comparable<T2>, T2> isLessOrEquals(plant: AssertionPlant<T1>, expected: T2): <ERROR CLASS>
inline fun <T1 : Comparable<T2>, T2> isLessThan(plant: AssertionPlant<T1>, expected: T2): <ERROR CLASS>

object FeatureAssertionsBuilder : FeatureAssertions

inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable): AssertionPlantNullable<TProperty>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>

object FloatingPointAssertionsBuilder : FloatingPointAssertions

inline fun toBeWithErrorTolerance(plant: AssertionPlant<Float>, expected: Float, tolerance: Float): <ERROR CLASS>
inline fun toBeWithErrorTolerance(plant: AssertionPlant<Double>, expected: Double, tolerance: Double): <ERROR CLASS>
inline fun <T : BigDecimal> toBeWithErrorTolerance(plant: AssertionPlant<T>, expected: T, tolerance: T): <ERROR CLASS>

object IterableAssertionsBuilder : IterableAssertions

inline fun <E : Any, T : Iterable<E?>> all(plant: AssertionPlant<T>, noinline assertionCreator: AssertionPlant<E>.() -> Unit): Assertion
inline val contains: IterableContainsAssertionsBuilder
inline fun <E, T : Iterable<E>> containsBuilder(plant: AssertionPlant<T>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> containsNotBuilder(plant: AssertionPlant<T>): <ERROR CLASS>

object IterableContainsAssertionsBuilder : IterableContainsAssertions

inline fun <E : Any, T : Iterable<E?>> entriesInAnyOrder(checkerOption: CheckerOption<E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): <ERROR CLASS>
inline fun <E : Any, T : Iterable<E?>> entriesInAnyOrderOnly(builder: Builder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): <ERROR CLASS>
inline fun <E : Any, T : Iterable<E?>> entriesInOrderOnly(builder: Builder<E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): <ERROR CLASS>
inline fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyGrouped(builder: Builder<E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<AssertionPlant<E>.() -> Unit>>): Assertion
inline val searchBehaviours: IterableContainsSearchBehaviourFactoryBuilder
inline fun <E, T : Iterable<E>> valuesInAnyOrder(checkerOption: CheckerOption<E, T, InAnyOrderSearchBehaviour>, expected: List<E>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> valuesInAnyOrderOnly(builder: Builder<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> valuesInOrderOnly(builder: Builder<E, T, InOrderOnlySearchBehaviour>, expected: List<E>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> valuesInOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>): Assertion

object IterableContainsSearchBehaviourFactoryBuilder : SearchBehaviourFactory

inline fun <E, T : Iterable<E>> inAnyOrder(builder: Builder<E, T, NoOpSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inAnyOrderOnly(builder: Builder<E, T, InAnyOrderSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrder(builder: Builder<E, T, NoOpSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrderOnly(builder: Builder<E, T, InOrderSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlySearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrderOnlyGroupedWithin(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>): <ERROR CLASS>

object MapAssertionsBuilder : MapAssertions

inline fun <T : Map<*, *>> hasSize(plant: AssertionPlant<T>, size: Int): <ERROR CLASS>
inline fun <T : Map<*, *>> isEmpty(plant: AssertionPlant<T>): <ERROR CLASS>
inline fun <T : Map<*, *>> isNotEmpty(plant: AssertionPlant<T>): <ERROR CLASS>

class PleaseUseReplacementException : Exception

PleaseUseReplacementException(reason: String)

object ThrowableAssertionsBuilder : ThrowableAssertions

inline val thrown: ThrowableThrownAssertionsBuilder
inline fun thrownBuilder(assertionVerb: Translatable, noinline act: () -> Unit, reporter: Reporter): Builder

object ThrowableThrownAssertionsBuilder : ThrowableThrownAssertions

inline val providers: AbsentThrowableMessageProviderFactoryBuilder
inline fun <TExpected : Throwable> toBe(throwableThrownBuilder: Builder, expectedType: KClass<TExpected>, noinline assertionCreator: AssertionPlant<TExpected>.() -> Unit): <ERROR CLASS>

package ch.tutteli.atrium.domain.builders.creating.charsequence.contains.builders

abstract class AtLeastCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>

AtLeastCheckerOptionBase(times: Int, containsBuilder: Builder<T, S>, nameContainsNotFun: String, atLeastCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<T, S>
val times: Int

abstract class AtMostCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>

AtMostCheckerOptionBase(times: Int, containsBuilder: Builder<T, S>, nameContainsNotFun: String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<T, S>
val times: Int

abstract class ButAtMostCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>

ButAtMostCheckerOptionBase(times: Int, atLeastBuilder: WithTimesCheckerOption<T, S>, containsBuilder: Builder<T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<T, S>
val times: Int

abstract class ExactlyCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>

ExactlyCheckerOptionBase(times: Int, containsBuilder: Builder<T, S>, nameContainsNotFun: String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<T, S>
val times: Int

abstract class NotCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>

NotCheckerOptionBase(containsBuilder: Builder<T, S>)
open val checkers: <ERROR CLASS>
open val containsBuilder: Builder<T, S>

abstract class NotOrAtMostCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>

NotOrAtMostCheckerOptionBase(times: Int, containsBuilder: Builder<T, S>, nameContainsNotFun: String, notOrAtMostCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<T, S>
val times: Int

interface WithTimesCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>

abstract val times: Int

package ch.tutteli.atrium.domain.builders.creating.collectors

object AssertionCollectorBuilder : AssertionCollector

inline fun <T : Any> collect(noinline subjectProvider: () -> T, noinline subPlantAndAssertionCreator: CollectingAssertionPlant<T>.() -> Unit): AssertionGroup
inline val forExplanation: ExplainingAssertionCollectorOption

object ExplainingAssertionCollectorOption

inline val doNotThrowIfNoAssertionIsCollected: NonThrowingAssertionCollectorForExplanation
inline val throwIfNoAssertionIsCollected: ThrowingAssertionCollectorForExplanation

package ch.tutteli.atrium.domain.builders.creating.iterable.contains.builders

abstract class AtLeastCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>

AtLeastCheckerOptionBase(times: Int, containsBuilder: Builder<E, T, S>, nameContainsNotFun: String, atLeastCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<E, T, S>
val times: Int

abstract class AtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>

AtMostCheckerOptionBase(times: Int, containsBuilder: Builder<E, T, S>, nameContainsNotFun: String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<E, T, S>
val times: Int

abstract class ButAtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>

ButAtMostCheckerOptionBase(times: Int, atLeastBuilder: WithTimesCheckerOption<E, T, S>, containsBuilder: Builder<E, T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<E, T, S>
val times: Int

abstract class ExactlyCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>

ExactlyCheckerOptionBase(times: Int, containsBuilder: Builder<E, T, S>, nameContainsNotFun: String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<E, T, S>
val times: Int

abstract class NotCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>

NotCheckerOptionBase(containsBuilder: Builder<E, T, S>)
open val checkers: <ERROR CLASS>
open val containsBuilder: Builder<E, T, S>

abstract class NotOrAtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>

NotOrAtMostCheckerOptionBase(times: Int, containsBuilder: Builder<E, T, S>, nameContainsNotFun: String, notOrAtMostCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<E, T, S>
val times: Int

interface WithTimesCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>

abstract val times: Int

package ch.tutteli.atrium.domain.builders.reporting

data class AssertionFormatterChosenOptions

AssertionFormatterChosenOptions(assertionFormatterFacade: AssertionFormatterFacade, objectFormatter: ObjectFormatter, translator: Translator)
val assertionFormatterFacade: AssertionFormatterFacade
val objectFormatter: ObjectFormatter
val translator: Translator

interface AssertionFormatterControllerOption

fun create(objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatterControllerOption
abstract val objectFormatter: ObjectFormatter
abstract val translator: Translator
abstract fun withAssertionFormatterController(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacadeOption
abstract fun withDefaultAssertionFormatterController(): AssertionFormatterFacadeOption

interface AssertionFormatterFacadeOption

abstract val assertionFormatterController: AssertionFormatterController
fun create(assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatterFacadeOption
abstract val objectFormatter: ObjectFormatter
abstract val translator: Translator
abstract fun withAssertionFormatterFacade(factory: (AssertionFormatterController) -> AssertionFormatterFacade): AssertionPairFormatterOption
abstract fun withDefaultAssertionFormatterFacade(): AssertionPairFormatterOption

interface AssertionPairFormatterOption

fun create(assertionFormatterFacade: AssertionFormatterFacade, objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatterOption
fun create(options: AssertionFormatterChosenOptions): AssertionPairFormatterOption
abstract val options: AssertionFormatterChosenOptions
abstract fun withTextAssertionPairFormatter(factory: (ObjectFormatter, Translator) -> AssertionPairFormatter): TextAssertionFormatterOption
abstract fun withTextSameLineAssertionPairFormatter(): TextAssertionFormatterOption

interface LocaleOrderDeciderOption

fun create(translationSupplier: TranslationSupplier): LocaleOrderDeciderOption
abstract val translationSupplier: TranslationSupplier
abstract fun withDefaultLocaleOrderDecider(): TranslatorOption
abstract fun withLocaleOrderDecider(localeOrderDecider: LocaleOrderDecider): TranslatorOption

interface ObjectFormatterOption

fun create(translator: Translator): ObjectFormatterOption
abstract val translator: Translator
abstract fun withDetailedObjectFormatter(): AssertionFormatterControllerOption
abstract fun withObjectFormatter(factory: (Translator) -> ObjectFormatter): AssertionFormatterControllerOption

interface ReporterBuilder

abstract fun withDefaultTranslationSupplier(): LocaleOrderDeciderOption
abstract fun withTranslationSupplier(translationSupplier: TranslationSupplier): LocaleOrderDeciderOption
abstract fun withTranslator(translator: Translator): ObjectFormatterOption
abstract fun withoutTranslations(primaryLocale: Locale = Locale.getDefault()): ObjectFormatterOption

interface ReporterBuilderFinalStep

abstract fun build(): Reporter
fun create(factory: () -> Reporter): ReporterBuilderFinalStep

interface ReporterOption

abstract val assertionFormatterFacade: AssertionFormatterFacade
fun create(assertionFormatterFacade: AssertionFormatterFacade): ReporterOption
abstract fun withCustomReporter(factory: (AssertionFormatterFacade) -> Reporter): ReporterBuilderFinalStep
abstract fun withOnlyFailureReporter(): ReporterBuilderFinalStep

interface TextAssertionFormatterOption

abstract val assertionPairFormatter: AssertionPairFormatter
fun create(options: AssertionFormatterChosenOptions, assertionPairFormatter: AssertionPairFormatter): TextAssertionFormatterOption
abstract val options: AssertionFormatterChosenOptions
abstract fun withDefaultTextCapabilities(vararg bulletPoints: <ERROR CLASS><Class<out BulletPointIdentifier>, String>): ReporterOption
abstract fun withTextAssertionFormatter(factory: (AssertionFormatterChosenOptions) -> (AssertionFormatterController) -> AssertionFormatter, vararg otherFactories: (AssertionFormatterChosenOptions) -> (AssertionFormatterController) -> AssertionFormatter): ReporterOption

interface TranslatorOption

abstract val localeOrderDecider: LocaleOrderDecider
abstract val translationSupplier: TranslationSupplier
abstract fun withDefaultTranslator(primaryLocale: Locale, vararg fallbackLocales: Locale): ObjectFormatterOption
abstract fun withTranslator(factory: (TranslationSupplier, LocaleOrderDecider) -> Translator): ObjectFormatterOption

val reporterBuilder: ReporterBuilder

package ch.tutteli.atrium.domain.builders.utils

interface Group<out T>

abstract fun toList(): List<T>

interface GroupWithNullableEntries<out T> : Group<T>
interface GroupWithoutNullableEntries<out T : Any> : Group<T>
fun <T> groupsToList(firstGroup: Group<T>, secondGroup: Group<T>, otherGroups: Array<out Group<T>>): List<List<T>>
inline fun <T> nullable(t: T): T?
inline fun <T> nullable(t: KFunction0<T>): KFunction0<T?>
inline fun <T1, R> nullable(t: KFunction1<T1, R>): KFunction1<T1, R?>
inline fun <T1, T2, R> nullable(t: KFunction2<T1, T2, R>): KFunction2<T1, T2, R?>
inline fun <T1, T2, T3, R> nullable(t: KFunction3<T1, T2, T3, R>): KFunction3<T1, T2, T3, R?>
inline fun <T1, T2, T3, T4, R> nullable(t: KFunction4<T1, T2, T3, T4, R>): KFunction4<T1, T2, T3, T4, R?>
inline fun <T1, T2, T3, T4, T5, R> nullable(t: KFunction5<T1, T2, T3, T4, T5, R>): KFunction5<T1, T2, T3, T4, T5, R?>
inline fun <T> nullableContainer(iterable: Iterable<T>): Iterable<T?>
inline fun <T> nullableContainer(arr: Array<out T>): Array<out T?>
inline fun <K, V : Any> nullableKeyMap(map: Map<out K, V>): Map<out K?, V>
inline fun <K : Any, V> nullableValueMap(map: Map<K, V>): Map<K, V?>
inline fun <T : Any> subAssert(noinline assertionCreator: AssertionPlant<T>.() -> Unit): AssertionPlant<T>.() -> Unit
fun validateAtMost(times: Int, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String): Unit
fun validateButAtMost(atLeastTimes: Int, butAtMostTimes: Int, atLeastButAtMostCall: (Int, Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String): Unit

package ch.tutteli.atrium.domain.creating

interface AnyAssertions

abstract fun <T : Any> isNotSame(plant: AssertionPlant<T>, expected: T): Assertion
abstract fun <T> isNull(plant: AssertionPlantNullable<T>): Assertion
abstract fun <T : Any> isSame(plant: AssertionPlant<T>, expected: T): Assertion
abstract fun <T : Any> notToBe(plant: AssertionPlant<T>, expected: T): Assertion
abstract fun <T : Any> toBe(plant: AssertionPlant<T>, expected: T): Assertion

interface BigDecimalAssertions

abstract fun <T : BigDecimal> isEqualIncludingScale(plant: AssertionPlant<T>, expected: T, nameOfIsNumericallyEqualTo: String): Assertion
abstract fun <T : BigDecimal> isNotEqualIncludingScale(plant: AssertionPlant<T>, expected: T): Assertion
abstract fun <T : BigDecimal> isNotNumericallyEqualTo(plant: AssertionPlant<T>, expected: T): Assertion
abstract fun <T : BigDecimal> isNumericallyEqualTo(plant: AssertionPlant<T>, expected: T): Assertion

interface CharSequenceAssertions

abstract fun <T : CharSequence> containsBuilder(plant: AssertionPlant<T>): Builder<T, NoOpSearchBehaviour>
abstract fun <T : CharSequence> containsNotBuilder(plant: AssertionPlant<T>): Builder<T, NotSearchBehaviour>
abstract fun <T : CharSequence> endsNotWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion
abstract fun <T : CharSequence> endsWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion
abstract fun <T : CharSequence> isEmpty(plant: AssertionPlant<T>): Assertion
abstract fun <T : CharSequence> isNotEmpty(plant: AssertionPlant<T>): Assertion
abstract fun <T : CharSequence> startsNotWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion
abstract fun <T : CharSequence> startsWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion

interface CollectionAssertions

abstract fun <T : Collection<*>> hasSize(plant: AssertionPlant<T>, size: Int): Assertion
abstract fun <T : Collection<*>> isEmpty(plant: AssertionPlant<T>): Assertion
abstract fun <T : Collection<*>> isNotEmpty(plant: AssertionPlant<T>): Assertion

interface ComparableAssertions

abstract fun <T1 : Comparable<T2>, T2> isGreaterOrEquals(plant: AssertionPlant<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isGreaterThan(plant: AssertionPlant<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isLessOrEquals(plant: AssertionPlant<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isLessThan(plant: AssertionPlant<T1>, expected: T2): Assertion

interface FeatureAssertions

abstract fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, name: Translatable): AssertionPlant<TProperty>
abstract fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, representationProvider: () -> Any?, name: Translatable): AssertionPlant<TProperty>
abstract fun <T : Any, TProperty> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, name: Translatable): AssertionPlantNullable<TProperty>
abstract fun <T : Any, TProperty> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, representationProvider: () -> Any?, name: Translatable): AssertionPlantNullable<TProperty>
abstract fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, name: String): AssertionPlant<R>
abstract fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>

interface FloatingPointAssertions

abstract fun toBeWithErrorTolerance(plant: AssertionPlant<Float>, expected: Float, tolerance: Float): Assertion
abstract fun toBeWithErrorTolerance(plant: AssertionPlant<Double>, expected: Double, tolerance: Double): Assertion
abstract fun <T : BigDecimal> toBeWithErrorTolerance(plant: AssertionPlant<T>, expected: T, tolerance: T): Assertion

interface IterableAssertions

abstract fun <E : Any, T : Iterable<E?>> all(plant: AssertionPlant<T>, assertionCreator: AssertionPlant<E>.() -> Unit): Assertion
abstract fun <E, T : Iterable<E>> containsBuilder(plant: AssertionPlant<T>): Builder<E, T, NoOpSearchBehaviour>
abstract fun <E, T : Iterable<E>> containsNotBuilder(plant: AssertionPlant<T>): Builder<E, T, NotSearchBehaviour>

interface MapAssertions

abstract fun <T : Map<*, *>> hasSize(plant: AssertionPlant<T>, size: Int): Assertion
abstract fun <T : Map<*, *>> isEmpty(plant: AssertionPlant<T>): Assertion
abstract fun <T : Map<*, *>> isNotEmpty(plant: AssertionPlant<T>): Assertion

interface ThrowableAssertions

abstract fun thrownBuilder(assertionVerb: Translatable, act: () -> Unit, reporter: Reporter): Builder

val anyAssertions: <ERROR CLASS>
val bigDecimalAssertions: <ERROR CLASS>
val charSequenceAssertions: <ERROR CLASS>
val collectionAssertions: <ERROR CLASS>
val comparableAssertions: <ERROR CLASS>
val featureAssertions: <ERROR CLASS>
val floatingPointAssertions: <ERROR CLASS>
val iterableAssertions: <ERROR CLASS>
val mapAssertions: <ERROR CLASS>
val throwableAssertions: <ERROR CLASS>

package ch.tutteli.atrium.domain.creating.any.typetransformation

interface AnyTypeTransformation

interface Creator<S : Any, T : Any>

abstract fun create(parameterObject: ParameterObject<S, T>, canBeTransformed: (S) -> Boolean, transform: (S) -> T, failureHandler: FailureHandler<S, T>): Unit

interface FailureHandler<in S : Any, out T : Any>

abstract fun createAndAddAssertionToPlant(parameterObject: ParameterObject<S, T>): Unit
abstract fun createFailingAssertion(description: Translatable, representation: Any): Assertion

data class ParameterObject<out S : Any, in T : Any>

ParameterObject(description: Translatable, representation: Any, subjectPlant: BaseAssertionPlant<S?, *>, assertionCreator: AssertionPlant<T>.() -> Unit, warningTransformationFailed: Translatable)
val assertionCreator: AssertionPlant<T>.() -> Unit
val description: Translatable
val representation: Any
val subjectPlant: BaseAssertionPlant<S?, *>
val warningTransformationFailed: Translatable

package ch.tutteli.atrium.domain.creating.any.typetransformation.creators

interface AnyTypeTransformationAssertions

abstract fun <T : Any, TSub : T> downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit, failureHandler: FailureHandler<T, TSub>): Unit
abstract fun <TSub : Any> isA(plant: AssertionPlant<Any>, subType: KClass<TSub>, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
abstract fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, assertionCreator: AssertionPlant<T>.() -> Unit): Unit
abstract fun <S : Any, T : Any> transform(parameterObject: ParameterObject<S, T>, canBeTransformed: (S) -> Boolean, transform: (S) -> T, failureHandler: FailureHandler<S, T>): Unit

val anyAssertions: <ERROR CLASS>
val anyTypeTransformationAssertions: <ERROR CLASS>

package ch.tutteli.atrium.domain.creating.any.typetransformation.failurehandlers

interface FailureHandlerFactory

abstract fun <S : Any, T : Any> newExplanatory(): FailureHandler<S, T>
abstract fun <S : Any, T : Any> newExplanatoryWithHint(showHint: () -> Boolean, failureHintFactory: () -> Assertion): FailureHandler<S, T>

val failureHandlerFactory: <ERROR CLASS>

package ch.tutteli.atrium.domain.creating.basic.contains

interface Contains

interface Builder<out T : Any, out S : SearchBehaviour>

abstract val plant: AssertionPlant<T>
abstract val searchBehaviour: S

interface Checker

abstract fun createAssertion(foundNumberOfTimes: Int): Assertion

interface CheckerOption<out T : Any, out S : SearchBehaviour, out C : Checker, out B : Builder<T, S>>

abstract val checkers: List<C>
abstract val containsBuilder: B

interface Creator<in T : Any, in SC>

abstract fun createAssertionGroup(plant: AssertionPlant<T>, searchCriteria: List<SC>): AssertionGroup

interface SearchBehaviour

abstract fun decorateDescription(description: Translatable): Translatable

package ch.tutteli.atrium.domain.creating.charsequence.contains

interface CharSequenceContains

interface Builder<out T : CharSequence, out S : SearchBehaviour> : Builder<T, S>
interface Checker : Checker
interface CheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S, Checker, Builder<T, S>>
interface Creator<in T : CharSequence, in SC> : Creator<T, SC>
interface SearchBehaviour : SearchBehaviour
interface Searcher<S : SearchBehaviour>

abstract fun search(searchIn: CharSequence, searchFor: Any): Int

fun <T : CharSequence, S : SearchBehaviour> CheckerOption<T, S>.addAssertion(assertion: Assertion): AssertionPlant<T>

package ch.tutteli.atrium.domain.creating.charsequence.contains.checkers

interface CheckerFactory

abstract fun newAtLeastChecker(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String): Checker
abstract fun newAtMostChecker(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String): Checker
abstract fun newExactlyChecker(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String): Checker
abstract fun newNotChecker(): Checker

val checkerFactory: <ERROR CLASS>

package ch.tutteli.atrium.domain.creating.charsequence.contains.creators

interface CharSequenceContainsAssertions

abstract fun <T : CharSequence> defaultTranslationOf(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Translatable>): AssertionGroup
abstract fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Translatable>): AssertionGroup
abstract fun <T : CharSequence> regex(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<String>): AssertionGroup
abstract fun <T : CharSequence> regexIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<String>): AssertionGroup
abstract fun <T : CharSequence> values(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Any>): AssertionGroup
abstract fun <T : CharSequence> valuesIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Any>): AssertionGroup

val charSequenceContainsAssertions: <ERROR CLASS>

package ch.tutteli.atrium.domain.creating.charsequence.contains.searchbehaviours

interface IgnoringCaseSearchBehaviour : SearchBehaviour
interface NoOpSearchBehaviour : SearchBehaviour

open fun decorateDescription(description: Translatable): Translatable

interface NotSearchBehaviour : NoOpSearchBehaviour
interface SearchBehaviourFactory

abstract fun <T : CharSequence> ignoringCase(containsBuilder: Builder<T, NoOpSearchBehaviour>): Builder<T, IgnoringCaseSearchBehaviour>

val searchBehaviourFactory: <ERROR CLASS>

package ch.tutteli.atrium.domain.creating.collectors

interface AssertionCollector

open fun <T : Any> collect(plant: AssertionPlant<T>, subPlantAndAssertionCreator: CollectingAssertionPlant<T>.() -> Unit): AssertionGroup
abstract fun <T : Any> collect(subjectProvider: () -> T, subPlantAndAssertionCreator: CollectingAssertionPlant<T>.() -> Unit): AssertionGroup

interface NonThrowingAssertionCollectorForExplanation

abstract fun <E : Any> collect(warning: Translatable, assertionCreator: AssertionPlant<E>.() -> Unit, subject: E?): List<Assertion>

interface ThrowingAssertionCollectorForExplanation

abstract fun <E : Any> collect(warning: Translatable, assertionCreator: AssertionPlant<E>.() -> Unit, subject: E?): List<Assertion>

val assertionCollector: AssertionCollector
val nonThrowingAssertionCollectorForExplanation: NonThrowingAssertionCollectorForExplanation
val throwingAssertionCollectorForExplanation: ThrowingAssertionCollectorForExplanation

package ch.tutteli.atrium.domain.creating.iterable.contains

interface IterableContains

interface Builder<out E, out T : Iterable<E>, out S : SearchBehaviour> : Builder<T, S>
interface Checker : Checker
interface CheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<T, S, Checker, Builder<E, T, S>>
interface Creator<in T : Iterable<*>, in SC> : Creator<T, SC>
interface SearchBehaviour : SearchBehaviour

fun <E, T : Iterable<E>, S : SearchBehaviour> CheckerOption<E, T, S>.addAssertion(assertion: Assertion): AssertionPlant<T>

package ch.tutteli.atrium.domain.creating.iterable.contains.checkers

interface CheckerFactory

abstract fun newAtLeastChecker(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String): Checker
abstract fun newAtMostChecker(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String): Checker
abstract fun newExactlyChecker(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String): Checker
abstract fun newNotChecker(): Checker

val checkerFactory: <ERROR CLASS>

package ch.tutteli.atrium.domain.creating.iterable.contains.creators

interface IterableContainsAssertions

abstract fun <E : Any, T : Iterable<E?>> entriesInAnyOrder(checkerOption: CheckerOption<E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInAnyOrderOnly(builder: Builder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInOrderOnly(builder: Builder<E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyGrouped(builder: Builder<E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<AssertionPlant<E>.() -> Unit>>): Assertion
abstract fun <E, T : Iterable<E>> valuesInAnyOrder(checkerOption: CheckerOption<E, T, InAnyOrderSearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInAnyOrderOnly(builder: Builder<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInOrderOnly(builder: Builder<E, T, InOrderOnlySearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>): Assertion

val iterableContainsAssertions: <ERROR CLASS>

package ch.tutteli.atrium.domain.creating.iterable.contains.searchbehaviours

interface InAnyOrderOnlySearchBehaviour : SearchBehaviour
interface InAnyOrderSearchBehaviour : SearchBehaviour
interface InOrderOnlyGroupedSearchBehaviour : SearchBehaviour
interface InOrderOnlyGroupedWithinSearchBehaviour : InOrderOnlyGroupedSearchBehaviour
interface InOrderOnlySearchBehaviour : SearchBehaviour
interface InOrderSearchBehaviour : SearchBehaviour
interface NoOpSearchBehaviour : SearchBehaviour

open fun decorateDescription(description: Translatable): Translatable

interface NotSearchBehaviour : InAnyOrderSearchBehaviour
interface SearchBehaviourFactory

abstract fun <E, T : Iterable<E>> inAnyOrder(builder: Builder<E, T, NoOpSearchBehaviour>): Builder<E, T, InAnyOrderSearchBehaviour>
abstract fun <E, T : Iterable<E>> inAnyOrderOnly(builder: Builder<E, T, InAnyOrderSearchBehaviour>): Builder<E, T, InAnyOrderOnlySearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrder(builder: Builder<E, T, NoOpSearchBehaviour>): Builder<E, T, InOrderSearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnly(builder: Builder<E, T, InOrderSearchBehaviour>): Builder<E, T, InOrderOnlySearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlySearchBehaviour>): Builder<E, T, InOrderOnlyGroupedSearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnlyGroupedWithin(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>): Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>

val searchBehaviourFactory: <ERROR CLASS>

package ch.tutteli.atrium.domain.creating.throwable.thrown

interface ThrowableThrown

interface AbsentThrowableMessageProvider

abstract val message: RawString

interface Builder

abstract val act: () -> Unit
abstract val assertionVerb: Translatable
abstract val reporter: Reporter

interface Creator<TExpected : Throwable>

abstract fun executeActAndCreateAssertion(throwableThrownBuilder: Builder, description: Translatable, expectedType: KClass<TExpected>, assertionCreator: AssertionPlant<TExpected>.() -> Unit): Unit

package ch.tutteli.atrium.domain.creating.throwable.thrown.creators

interface ThrowableThrownAssertions

abstract fun <TExpected : Throwable> toBe(throwableThrownBuilder: Builder, expectedType: KClass<TExpected>, assertionCreator: AssertionPlant<TExpected>.() -> Unit): Unit

val throwableThrownAssertions: <ERROR CLASS>

package ch.tutteli.atrium.domain.creating.throwable.thrown.providers

interface AbsentThrowableMessageProviderFactory

abstract fun translatableBased(translatable: Translatable): AbsentThrowableMessageProvider

val absentThrowableMessageProviderFactory: <ERROR CLASS>

package ch.tutteli.atrium.reporting

interface AssertionFormatter

val CALL_FORMAT_GROUP: String
abstract fun canFormat(assertion: Assertion): Boolean
open fun format(assertion: Assertion, parameterObject: AssertionFormatterParameterObject): Unit
abstract fun formatGroup(assertionGroup: AssertionGroup, parameterObject: AssertionFormatterParameterObject, formatAssertions: (AssertionFormatterParameterObject, (Assertion) -> Unit) -> Unit): Unit
abstract fun formatNonGroup(assertion: Assertion, parameterObject: AssertionFormatterParameterObject): Unit
fun throwNotIntendedForAssertionGroups(): Unit

interface AssertionFormatterController

abstract fun format(assertion: Assertion, parameterObject: AssertionFormatterParameterObject): Unit
open fun isExplanatoryAssertionGroup(assertion: Assertion): Boolean
fun noSuitableAssertionFormatterFound(assertion: Assertion): Nothing
abstract fun register(assertionFormatter: AssertionFormatter): Unit

interface AssertionFormatterFacade

abstract fun format(assertion: Assertion, sb: StringBuilder, assertionFilter: (Assertion) -> Boolean): Unit
abstract fun register(assertionFormatterFactory: (AssertionFormatterController) -> AssertionFormatter): Unit

class AssertionFormatterParameterObject

fun appendLnAndIndent(): Unit
fun appendLnIndentAndPrefix(): Unit
val assertionFilter: (Assertion) -> Boolean
fun createChildWithNewPrefix(newPrefix: String): AssertionFormatterParameterObject
fun createChildWithNewPrefixAndAdditionalIndent(newPrefix: String, additionalIndent: Int): AssertionFormatterParameterObject
fun createForDoNotFilterAssertionGroup(): AssertionFormatterParameterObject
fun indent(numberOfSpaces: Int): Unit
fun isNotInDoNotFilterGroup(): Boolean
fun new(sb: StringBuilder, assertionFilter: (Assertion) -> Boolean): AssertionFormatterParameterObject
val prefix: String
val sb: StringBuilder

interface AssertionPairFormatter

abstract fun format(parameterObject: AssertionFormatterParameterObject, translatable: Translatable, representation: Any): Unit
abstract fun formatGroupHeader(parameterObject: AssertionFormatterParameterObject, assertionGroup: AssertionGroup, newParameterObject: AssertionFormatterParameterObject): Unit

const val BUG_REPORT_URL: String
class LazyRepresentation

LazyRepresentation(provider: () -> Any)
fun eval(): Any

interface MethodCallFormatter

abstract fun format(name: String, arguments: Array<out Any?>): () -> String

interface ObjectFormatter

abstract fun format(value: Any?): String

interface RawString

val EMPTY: RawString
val NULL: StringBasedRawString
fun create(string: String): RawString
fun create(translatable: Translatable): RawString

interface Reporter

abstract fun format(assertion: Assertion, sb: StringBuilder): Unit

class ReporterBuilder

ReporterBuilder(assertionFormatterFacade: AssertionFormatterFacade)
class AssertionFormatterChosenOptions

AssertionFormatterChosenOptions(assertionFormatterFacade: AssertionFormatterFacade, objectFormatter: ObjectFormatter, translator: Translator)
val assertionFormatterFacade: AssertionFormatterFacade
val objectFormatter: ObjectFormatter
val translator: Translator

class AssertionFormatterControllerOptions

AssertionFormatterControllerOptions(objectFormatter: ObjectFormatter, translator: Translator)
fun withAssertionFormatterController(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacadeOptions
fun withDefaultAssertionFormatterController(): AssertionFormatterFacadeOptions

class AssertionFormatterFacadeOptions

AssertionFormatterFacadeOptions(assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator)
fun withAssertionFormatterFacade(factory: (AssertionFormatterController) -> AssertionFormatterFacade): AssertionPairFormatterOptions
fun withDefaultAssertionFormatterFacade(): AssertionPairFormatterOptions

class AssertionPairFormatterOptions

AssertionPairFormatterOptions(options: AssertionFormatterChosenOptions)
fun withSameLineTextAssertionFormatter(vararg bulletPoints: <ERROR CLASS><Class<out BulletPointIdentifier>, String>): ReporterBuilder
fun withTextAssertionPairFormatter(factory: (ObjectFormatter, Translator) -> AssertionPairFormatter): TextAssertionFormatterOptions
fun withTextSameLineAssertionPairFormatter(): TextAssertionFormatterOptions

class LocaleOrderDeciderOptions

LocaleOrderDeciderOptions(translationSupplier: TranslationSupplier)
fun withDefaultLocaleOrderDecider(): TranslatorOptions
fun withLocaleOrderDecider(localeOrderDecider: LocaleOrderDecider): TranslatorOptions

class ObjectFormatterOptions

ObjectFormatterOptions(translator: Translator)
fun withDetailedObjectFormatter(): AssertionFormatterControllerOptions
fun withObjectFormatter(factory: (Translator) -> ObjectFormatter): AssertionFormatterControllerOptions

class TextAssertionFormatterOptions

TextAssertionFormatterOptions(options: AssertionFormatterChosenOptions, assertionPairFormatter: AssertionPairFormatter)
fun withDefaultTextCapabilities(vararg bulletPoints: <ERROR CLASS><Class<out BulletPointIdentifier>, String>): ReporterBuilder
fun withTextAssertionFormatter(factory: (AssertionFormatterChosenOptions) -> (AssertionFormatterController) -> AssertionFormatter, vararg otherFactories: (AssertionFormatterChosenOptions) -> (AssertionFormatterController) -> AssertionFormatter): ReporterBuilder

class TranslatorOptions

TranslatorOptions(translationSupplier: TranslationSupplier, localeOrderDecider: LocaleOrderDecider)
fun withDefaultTranslator(primaryLocale: Locale, vararg fallbackLocales: Locale): ObjectFormatterOptions
fun withTranslator(factory: (TranslationSupplier, LocaleOrderDecider) -> Translator): ObjectFormatterOptions

fun buildCustomReporter(factory: (AssertionFormatterFacade) -> Reporter): Reporter
fun buildOnlyFailureReporter(): Reporter
fun withDefaultTranslationSupplier(): LocaleOrderDeciderOptions
fun withTranslationSupplier(translationSupplier: TranslationSupplier): LocaleOrderDeciderOptions
fun withTranslator(translator: Translator): ObjectFormatterOptions
fun withoutTranslations(primaryLocale: Locale = Locale.getDefault()): ObjectFormatterOptions

interface ReporterFactory

const val SYSTEM_PROPERTY: String
abstract fun create(): Reporter
abstract val id: String
fun specifyFactory(reporterFactoryId: String): String
fun specifyFactoryIfNotYetSet(reporterFactoryId: String): Unit

data class StringBasedRawString : RawString

val string: String

val reporter: <ERROR CLASS>

package ch.tutteli.atrium.reporting.translating

abstract class ArgumentsSupportingTranslator : Translator

ArgumentsSupportingTranslator(primaryLocale: Locale, fallbackLocales: List<Locale>)
protected val fallbackLocales: List<Locale>
protected val primaryLocale: Locale
fun translate(translatable: Translatable): String
protected abstract fun translateWithoutArgs(translatable: Translatable): String

interface LocaleOrderDecider

abstract fun determineOrder(primaryLocale: Locale, fallbackLocales: List<Locale>): <ERROR CLASS><Locale>

interface StringBasedTranslatable : Translatable

open fun getDefault(): String
abstract val value: String

interface Translatable

const val ID_SEPARATOR: String
abstract fun getDefault(): String
open val id: String
abstract val name: String

data class TranslatableBasedRawString : RawString

val translatable: Translatable

class TranslatableWithArgs : Translatable

TranslatableWithArgs(translatable: Translatable, argument: Any)
TranslatableWithArgs(translatable: Translatable, arg1: Any, vararg otherArguments: Any)
TranslatableWithArgs(translatable: Translatable, arguments: Array<Any>)
val arguments: Array<Any>
fun getDefault(): <ERROR CLASS>
val id: <ERROR CLASS>
val name: String
val translatable: Translatable

interface TranslationSupplier

abstract fun get(translatable: Translatable, locale: Locale): String?

interface Translator

abstract fun translate(translatable: Translatable): String

class Untranslatable : Translatable

Untranslatable(representation: CharSequence)
Untranslatable(representation: () -> String)
val EMPTY: Untranslatable
fun getDefault(): String
val name: String

class UsingDefaultTranslator : ArgumentsSupportingTranslator

UsingDefaultTranslator(primaryLocale: Locale = Locale.getDefault())
protected fun translateWithoutArgs(translatable: Translatable): String

package ch.tutteli.atrium.spec

class DeprecationTestEngine

DeprecationTestEngine()
fun discover(discoveryRequest: <ERROR CLASS>, uniqueId: <ERROR CLASS>): <ERROR CLASS>
fun execute(request: <ERROR CLASS>): <ERROR CLASS>
fun getId(): String

class ForgivingTest

ForgivingTest(test: <ERROR CLASS>)
fun execute(context: <ERROR CLASS>, dynamicTestExecutor: <ERROR CLASS>?): <ERROR CLASS>
fun getType(): <ERROR CLASS>
val parent: <ERROR CLASS>

package ch.tutteli.atrium.translations

enum class DescriptionAnyAssertion : StringBasedTranslatable

IS_NOT_SAME
IS_SAME
NOT_TO_BE
TO_BE
val value: String

enum class DescriptionBasic : StringBasedTranslatable

IS
IS_NOT
val value: String

enum class DescriptionBigDecimalAssertion : StringBasedTranslatable

FAILURE_IS_EQUAL_INCLUDING_SCALE_BUT_NUMERICALLY_EQUAL
IS_EQUAL_INCLUDING_SCALE
IS_NOT_EQUAL_INCLUDING_SCALE
IS_NOT_NUMERICALLY_EQUAL_TO
IS_NUMERICALLY_EQUAL_TO
val value: String

enum class DescriptionCharSequenceAssertion : StringBasedTranslatable

AT_LEAST
AT_MOST
CONTAINS
CONTAINS_NOT
EMPTY
ENDS_NOT_WITH
ENDS_WITH
EXACTLY
IGNORING_CASE
NUMBER_OF_OCCURRENCES
STARTS_NOT_WITH
STARTS_WITH
STRING_MATCHING_REGEX
VALUE
val value: String

enum class DescriptionCollectionAssertion : StringBasedTranslatable

EMPTY
val value: String

enum class DescriptionComparableAssertion : StringBasedTranslatable

IS_GREATER_OR_EQUALS
IS_GREATER_THAN
IS_LESS_OR_EQUALS
IS_LESS_THAN
val value: String

enum class DescriptionFloatingPointAssertion : StringBasedTranslatable

FAILURE_DUE_TO_FLOATING_POINT_NUMBER
TO_BE_WITH_ERROR_TOLERANCE
TO_BE_WITH_ERROR_TOLERANCE_EXPLAINED
val value: String

enum class DescriptionIterableAssertion : StringBasedTranslatable

ALL
AN_ENTRY_WHICH
AN_ENTRY_WHICH_IS
AT_LEAST
AT_MOST
CANNOT_EVALUATE_SUBJECT_EMPTY_ITERABLE
CANNOT_EVALUATE_SUBJECT_ONLY_NULL
CONTAINS
CONTAINS_NOT
ENTRY_WITH_INDEX
EXACTLY
HAS_ELEMENT
INDEX
INDEX_FROM_TO
IN_ANY_ORDER
IN_ANY_ORDER_ONLY
IN_ORDER
IN_ORDER_ONLY
IN_ORDER_ONLY_GROUPED
NUMBER_OF_OCCURRENCES
SIZE_EXCEEDED
WARNING_ADDITIONAL_ENTRIES
WARNING_MISMATCHES
WARNING_MISMATCHES_ADDITIONAL_ENTRIES
val value: String

enum class DescriptionMapAssertion : StringBasedTranslatable

EMPTY
val value: String

enum class DescriptionThrowableAssertion : StringBasedTranslatable

IS_A
NO_EXCEPTION_OCCURRED
OCCURRED_EXCEPTION_MESSAGE
OCCURRED_EXCEPTION_PROPERTIES
OCCURRED_EXCEPTION_STACKTRACE
val value: String

enum class DescriptionTypeTransformationAssertion : StringBasedTranslatable

IS_A
WARNING_DOWN_CAST_FAILED
val value: String

package ch.tutteli.atrium.verbs

enum class AssertionVerb : StringBasedTranslatable

ASSERT
ASSERT_THAT
ASSERT_THAT_THROWN
ASSERT_THROWN
EXPECT
EXPECT_THROWN
val value: String

fun <T : Any> assert(subject: T): <ERROR CLASS>
fun <T : Any> assert(subject: T, assertionCreator: Assert<T>.() -> Unit): <ERROR CLASS>
fun assert(act: () -> Unit): Builder
fun <T : Any> assertThat(subject: T): <ERROR CLASS>
fun <T : Any> assertThat(subject: T, assertionCreator: Assert<T>.() -> Unit): <ERROR CLASS>
fun assertThat(act: () -> Unit): Builder
fun <T : Any> expect(subject: T): <ERROR CLASS>
fun <T : Any> expect(subject: T, assertionCreator: Assert<T>.() -> Unit): <ERROR CLASS>
fun expect(act: () -> Unit): Builder

package ch.tutteli.atrium.verbs.assert

fun <T : Any> assert(subject: T): <ERROR CLASS>
fun <T : Any> assert(subject: T, assertionCreator: Assert<T>.() -> Unit): <ERROR CLASS>
fun assert(act: () -> Unit): Builder

package ch.tutteli.atrium.verbs.assertthat

fun <T : Any> assertThat(subject: T): <ERROR CLASS>
fun <T : Any> assertThat(subject: T, assertionCreator: Assert<T>.() -> Unit): <ERROR CLASS>
fun assertThat(act: () -> Unit): Builder

package ch.tutteli.atrium.verbs.expect

fun <T : Any> expect(subject: T): <ERROR CLASS>
fun <T : Any> expect(subject: T, assertionCreator: Assert<T>.() -> Unit): <ERROR CLASS>
fun expect(act: () -> Unit): Builder

package ch.tutteli.atrium.verbs.internal

enum class AssertionVerb : StringBasedTranslatable

ASSERT
EXPECT_THROWN
val value: String

object AssertionVerbFactory

fun checkException(act: () -> Unit): Builder
fun <T : Any> checkImmediately(subject: T): <ERROR CLASS>
fun <T : Any> checkLazily(subject: T, assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
fun <T> checkNullable(subject: T): <ERROR CLASS>

fun <T : Any> assert(subject: T): <ERROR CLASS>
fun <T : Any> assert(subject: T, assertionCreator: Assert<T>.() -> Unit): <ERROR CLASS>
fun expect(act: () -> Unit): Builder